Fixed compiler so that it passes Switch1NegativeTest.dart.

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 265 matching lines @@
 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 + " of " + this.dstName + " in " + this.url + " at line ") + ("" + this.line + ", column " + this.column + ".");
 }
+// ********** 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.forEach$1 = function(f) {
   return this.forEach(to$call$1(f));
 }
 function Duration() {}
 // ********** Code for IndexOutOfRangeException **************
 function IndexOutOfRangeException() {}
 IndexOutOfRangeException.prototype.toString = function() {
-  return ("IndexOutOfRangeException: " + this._dart_core_index + "");
+  return ("IndexOutOfRangeException: " + this._index + "");
 }
 // ********** Code for NoSuchMethodException **************
 function NoSuchMethodException() {}
 NoSuchMethodException.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   for (var i = 0;
    i < this._arguments.length; i++) {
     if (i > 0) {
       sb.add(", ");
     }
@@ skipping 22 matching lines @@
 // ********** 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._dart_core_message + "");
+  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;
@@ skipping 90 matching lines @@
 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$9/*const NoMoreElementsException()*/);
+    $throw(const$121/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._pos++);
 }
 // ********** 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;
@@ skipping 16 matching lines @@
 }
 // ********** 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$9/*const NoMoreElementsException()*/);
+    $throw(const$121/*const NoMoreElementsException()*/);
   }
   var next = this._next;
   this._next = null;
   return next;
 }
 _AllMatchesIterator.prototype.hasNext = function() {
   if (this._done) {
     return false;
   }
   else if (this._next) {
@@ skipping 31 matching lines @@
 
     if (truncated == -0.0) return 0;
     return truncated;
 }
 NumImplementation.prototype.toDouble = function() {
   return this + 0;
 }
 NumImplementation.prototype.compareTo = function(other) {
   var thisValue = this.toDouble();
   if (thisValue < other) {
-    return -1;
+    return -1.000000/*-1*/;

[jimhug, 2011/10/27 17:45:11]

It looks like you didn't do a "true" selfhost build here?  If you build with
frogsh --out=frogsh frog.dart, I would expect better number formatting and for
these to just show up as -1.

   }
   else if (thisValue > other) {
     return 1;
   }
   else if (thisValue == other) {
     if (thisValue == 0) {
       var thisIsNegative = this.isNegative();
       var otherIsNegative = other.isNegative();
       if ($eq(thisIsNegative, otherIsNegative)) return 0;
-      if (thisIsNegative) return -1;
+      if (thisIsNegative) return -1.000000/*-1*/;
       return 1;
     }
     return 0;
   }
   else if (this.isNaN()) {
     if (other.isNaN()) {
       return 0;
     }
     return 1;
   }
   else {
-    return -1;
+    return -1.000000/*-1*/;
   }
 }
 // ********** Code for DurationImplementation **************
 function DurationImplementation(days, hours, minutes, seconds, milliseconds) {
-  this._durationInMilliseconds = 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;
+  this._durationInMilliseconds = days * 86400000.000000/*Duration.MILLISECONDS_PER_DAY*/ + hours * 3600000.000000/*Duration.MILLISECONDS_PER_HOUR*/ + minutes * 60000.000000/*Duration.MILLISECONDS_PER_MINUTE*/ + seconds * 1000/*Duration.MILLISECONDS_PER_SECOND*/ + milliseconds;
   // Initializers done
 }
 DurationImplementation.prototype.get$inHours = function() {
-  return $truncdiv(this._durationInMilliseconds, 3600000/*Duration.MILLISECONDS_PER_HOUR*/);
+  return $truncdiv(this._durationInMilliseconds, 3600000.000000/*Duration.MILLISECONDS_PER_HOUR*/);
 }
 DurationImplementation.prototype.get$inMinutes = function() {
-  return $truncdiv(this._durationInMilliseconds, 60000/*Duration.MILLISECONDS_PER_MINUTE*/);
+  return $truncdiv(this._durationInMilliseconds, 60000.000000/*Duration.MILLISECONDS_PER_MINUTE*/);
 }
 DurationImplementation.prototype.get$inSeconds = function() {
   return $truncdiv(this._durationInMilliseconds, 1000/*Duration.MILLISECONDS_PER_SECOND*/);
 }
 DurationImplementation.prototype.get$inMilliseconds = function() {
   return this._durationInMilliseconds;
 }
 DurationImplementation.prototype.$eq = function(other) {
   if (!((other instanceof DurationImplementation))) return false;
   return this._durationInMilliseconds == other.get$inMilliseconds();
@@ skipping 54 matching lines @@
 HashMapImplementation._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
 HashMapImplementation._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - 1);
 }
 HashMapImplementation.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
-  var insertionIndex = -1;
+  var insertionIndex = -1.000000/*-1*/;
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < 0) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   while (true) {
     var existingKey = this._keys.$index(hash);
-    if (existingKey == null) return -1;
+    if (existingKey == null) return -1.000000/*-1*/;
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + 1;
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.length * 2);
     return;
   }
@@ skipping 83 matching lines @@
 HashMapImplementation.prototype.getValues = function() {
   var list = new ListFactory$V(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, value);
   }
   );
   return list;
 }
 HashMapImplementation.prototype.containsKey = function(key) {
-  return (this._probeForLookup(key) != -1);
+  return (this._probeForLookup(key) != -1.000000/*-1*/);
 }
 HashMapImplementation.prototype.forEach$1 = HashMapImplementation.prototype.forEach;
 // ********** Code for HashMapImplementation$E$E **************
 function HashMapImplementation$E$E() {
   // 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*/);
   this._values = new ListFactory$E(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$E$E, HashMapImplementation);
 HashMapImplementation$E$E._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation$E$E._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
 HashMapImplementation$E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - 1);
 }
 HashMapImplementation$E$E.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
-  var insertionIndex = -1;
+  var insertionIndex = -1.000000/*-1*/;
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < 0) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation$E$E.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   while (true) {
     var existingKey = this._keys.$index(hash);
-    if (existingKey == null) return -1;
+    if (existingKey == null) return -1.000000/*-1*/;
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation$E$E.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + 1;
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.length * 2);
     return;
   }
@@ skipping 63 matching lines @@
 HashMapImplementation$E$E.prototype.getKeys = function() {
   var list = new ListFactory$E(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
   return list;
 }
 HashMapImplementation$E$E.prototype.containsKey = function(key) {
-  return (this._probeForLookup(key) != -1);
+  return (this._probeForLookup(key) != -1.000000/*-1*/);
 }
 // ********** Code for HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V **************
 function HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V() {
   // Initializers done
   if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
@@ skipping 99 matching lines @@
 }
 HashSetImplementation.prototype.forEach$1 = HashSetImplementation.prototype.forEach;
 // ********** Code for HashSetImplementation$E **************
 function HashSetImplementation$E() {
   // Initializers done
   this._backingMap = new HashMapImplementation$E$E();
 }
 $inherits(HashSetImplementation$E, HashSetImplementation);
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
-  this._nextValidIndex = -1;
+  this._nextValidIndex = -1.000000/*-1*/;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
 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$9/*const NoMoreElementsException()*/);
+    $throw(const$121/*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 {
     if (++this._nextValidIndex >= length) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
   while ((entry == null) || (entry === deletedKey))
 }
 // ********** Code for HashSetIterator$E **************
 function HashSetIterator$E(set_) {
-  this._nextValidIndex = -1;
+  this._nextValidIndex = -1.000000/*-1*/;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
 $inherits(HashSetIterator$E, HashSetIterator);
 HashSetIterator$E.prototype._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = HashMapImplementation._deletedKey;
   do {
@@ skipping 182 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$10/*const EmptyQueueException()*/);
+  $throw(const$122/*const EmptyQueueException()*/);
 }
 _DoubleLinkedQueueEntrySentinel.prototype._asNonSentinelEntry = function() {
   return null;
 }
 _DoubleLinkedQueueEntrySentinel.prototype.get$element = function() {
-  $throw(const$10/*const EmptyQueueException()*/);
+  $throw(const$122/*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 161 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$9/*const NoMoreElementsException()*/);
+    $throw(const$121/*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 396 matching lines @@
   get$vm().runInNewContext(code,
     {'require':require, 'process':process, 'console':console});
 }
 // ********** Code for ServerRequest **************
 // ********** Code for Process **************
 // ********** 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$325/*const LinkTail()*/ : tail);
+  return new LinkEntry(head, (tail == null) ? const$317/*const LinkTail()*/ : tail);
 }
 LinkFactory.Link$fromList$factory = function(list) {
   switch (list.length) {
     case 0:
 
-      return const$325/*const LinkTail()*/;
+      return const$317/*const LinkTail()*/;
+      $throw(new FallThroughError("./leg/util/link_implementation.dart", 12))
 
     case 1:
 
       return LinkFactory.Link$factory(list.$index(0));
+      $throw(new FallThroughError("./leg/util/link_implementation.dart", 14))
 
     case 2:
 
       return LinkFactory.Link$factory(list.$index(0), LinkFactory.Link$factory(list.$index(1)));
+      $throw(new FallThroughError("./leg/util/link_implementation.dart", 16))
 
     case 3:
 
       return LinkFactory.Link$factory(list.$index(0), LinkFactory.Link$factory(list.$index(1), LinkFactory.Link$factory(list.$index(2))));
 
   }
   var link = LinkFactory.Link$factory(list.last());
   for (var i = list.length - 1;
    i > 0; i--) {
     link = link.prepend(list.$index(i - 1));
@@ skipping 22 matching lines @@
   // 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$8/*const []*/;
+  return const$120/*const []*/;
 }
 LinkTail.prototype.isEmpty = function() {
   return true;
 }
 // ********** Code for LinkEntry **************
 function LinkEntry(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
 }
@@ skipping 28 matching lines @@
 Element.prototype.get$node = function() { return this.node; };
 Element.prototype.hashCode = function() {
   return this.name.hashCode();
 }
 // ********** Code for top level **************
 //  ********** Library scanner **************
 // ********** Code for AbstractScanner **************
 function AbstractScanner() {}
 AbstractScanner.prototype.tokenize = function() {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     next = this.bigSwitch(next);
   }
   return this.firstToken();
 }
 AbstractScanner.prototype.bigSwitch = function(next) {
   this.beginToken();
   switch (next) {
     case 9/*null.$TAB*/:
     case 10/*null.$LF*/:
     case 13/*null.$CR*/:
     case 32/*null.$SPACE*/:
 
       this.appendWhiteSpace(next);
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 62))
 
     case 60/*null.$LT*/:
 
       return this.tokenizeLessThan(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 65))

[jimhug, 2011/10/27 17:45:11]

Hopefully, this code - as well as our other similar tokenizer code below helps
capture the need for some minimal flow analysis to keep the generated code small
and readable?

[Emily Fortuna, 2011/10/27 17:59:04]

Yeah, I've reversed this change in r843. Will make a better solution for the
next CL.

On 2011/10/27 17:45:11, jimhug wrote:

 
     case 62/*null.$GT*/:
 
       return this.tokenizeGreaterThan(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 68))
 
     case 61/*null.$EQ*/:
 
       return this.tokenizeEquals(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 71))
 
     case 33/*null.$BANG*/:
 
       return this.tokenizeExclamation(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 74))
 
     case 43/*null.$PLUS*/:
 
       return this.tokenizePlus(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 77))
 
     case 45/*null.$MINUS*/:
 
       return this.tokenizeMinus(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 80))
 
     case 42/*null.$STAR*/:
 
       return this.tokenizeMultiply(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 83))
 
     case 37/*null.$PERCENT*/:
 
       return this.tokenizePercent(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 86))
 
     case 38/*null.$AMPERSAND*/:
 
       return this.tokenizeAmpersand(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 89))
 
     case 124/*null.$BAR*/:
 
       return this.tokenizeBar(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 92))
 
     case 94/*null.$CARET*/:
 
       return this.tokenizeCaret(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 95))
 
     case 91/*null.$LBRACKET*/:
 
       return this.tokenizeOpenBracket(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 98))
 
     case 126/*null.$TILDE*/:
 
       return this.tokenizeTilde(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 101))
 
     case 92/*null.$BACKSLASH*/:
 
       this.appendStringToken(next, "\\");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 105))
 
     case 35/*null.$HASH*/:
 
       return this.tokenizeTag(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 108))
 
     case 40/*null.$LPAREN*/:
 
       this.appendStringToken(next, "(");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 112))
 
     case 41/*null.$RPAREN*/:
 
       this.appendStringToken(next, ")");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 116))
 
     case 44/*null.$COMMA*/:
 
       this.appendStringToken(next, ",");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 120))
 
     case 58/*null.$COLON*/:
 
       this.appendStringToken(next, ":");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 124))
 
     case 59/*null.$SEMICOLON*/:
 
       this.appendStringToken(next, ";");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 128))
 
     case 63/*null.$QUESTION*/:
 
       this.appendStringToken(next, "?");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 132))
 
     case 93/*null.$RBRACKET*/:
 
       this.appendStringToken(next, "]");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 136))
 
     case 96/*null.$BACKPING*/:
 
       this.appendStringToken(next, "`");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 140))
 
     case 123/*null.$LBRACE*/:
 
       this.appendStringToken(next, "{");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 144))
 
     case 125/*null.$RBRACE*/:
 
       this.appendStringToken(next, "}");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 148))
 
     case 47/*null.$SLASH*/:
 
       return this.tokenizeSlashOrComment(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 151))
 
     case 64/*null.$AT*/:
 
       return this.tokenizeRawString(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 154))
 
     case 34/*null.$DQ*/:
     case 39/*null.$SQ*/:
 
       return this.tokenizeString(next, this.get$byteOffset(), false);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 158))
 
     case 46/*null.$PERIOD*/:
 
       return this.tokenizeDotOrNumber(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 161))
 
     case 48/*null.$0*/:
 
       return this.tokenizeHexOrNumber(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 164))
 
     case 49/*null.$1*/:
     case 50/*null.$2*/:
     case 51/*null.$3*/:
     case 52/*null.$4*/:
     case 53/*null.$5*/:
     case 54/*null.$6*/:
     case 55/*null.$7*/:
     case 56/*null.$8*/:
     case 57/*null.$9*/:
 
       return this.tokenizeNumber(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 175))
 
     case 36/*null.$DOLLAR*/:
     case 65/*null.$A*/:
     case 66/*null.$B*/:
     case 67/*null.$C*/:
     case 68/*null.$D*/:
     case 69/*null.$E*/:
     case 70/*null.$F*/:
     case 71/*null.$G*/:
     case 72/*null.$H*/:
@@ skipping 37 matching lines @@
     case 115/*null.$s*/:
     case 116/*null.$t*/:
     case 117/*null.$u*/:
     case 118/*null.$v*/:
     case 119/*null.$w*/:
     case 120/*null.$x*/:
     case 121/*null.$y*/:
     case 122/*null.$z*/:
 
       return this.tokenizeIdentifier(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 231))
 
     default:
 
-      if (next == -1) {
-        return -1;
+      if (next == -1.000000/*-1*/) {
+        return -1.000000/*-1*/;
       }
       if (next < 0x1f) {
         $throw(this.get$charOffset());
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 AbstractScanner.prototype.tokenizeTag = function(next) {
@@ skipping 32 matching lines @@
 AbstractScanner.prototype.tokenizeCaret = function(next) {
   return this.select(61/*null.$EQ*/, "^=", "^");
 }
 AbstractScanner.prototype.tokenizeBar = function(next) {
   next = this.advance();
   switch (next) {
     case 124/*null.$BAR*/:
 
       this.appendStringToken(124/*null.$BAR*/, "||");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 292))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(124/*null.$BAR*/, "|=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 295))
 
     default:
 
       this.appendStringToken(124/*null.$BAR*/, "|");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeAmpersand = function(next) {
   next = this.advance();
   switch (next) {
     case 38/*null.$AMPERSAND*/:
 
       this.appendStringToken(38/*null.$AMPERSAND*/, "&&");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 308))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(38/*null.$AMPERSAND*/, "&=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 311))
 
     default:
 
       this.appendStringToken(38/*null.$AMPERSAND*/, "&");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizePercent = function(next) {
   return this.select(61/*null.$EQ*/, "%=", "%");
 }
 AbstractScanner.prototype.tokenizeMultiply = function(next) {
   return this.select(61/*null.$EQ*/, "*=", "*");
 }
 AbstractScanner.prototype.tokenizeMinus = function(next) {
   next = this.advance();
   switch (next) {
     case 45/*null.$MINUS*/:
 
       this.appendStringToken(45/*null.$MINUS*/, "--");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 334))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(45/*null.$MINUS*/, "-=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 337))
 
     default:
 
       this.appendStringToken(45/*null.$MINUS*/, "-");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizePlus = function(next) {
   next = this.advance();
   switch (next) {
     case 43/*null.$PLUS*/:
 
       this.appendStringToken(43/*null.$PLUS*/, "++");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 350))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(43/*null.$PLUS*/, "+=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 353))
 
     default:
 
       this.appendStringToken(43/*null.$PLUS*/, "+");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeExclamation = function(next) {
   next = this.advance();
@@ skipping 11 matching lines @@
   this.appendStringToken(61/*null.$EQ*/, "=");
   return next;
 }
 AbstractScanner.prototype.tokenizeGreaterThan = function(next) {
   next = this.advance();
   switch (next) {
     case 61/*null.$EQ*/:
 
       this.appendStringToken(62/*null.$GT*/, ">=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 386))
 
     case 62/*null.$GT*/:
 
       next = this.advance();
       switch (next) {
         case 61/*null.$EQ*/:
 
           this.appendStringToken(62/*null.$GT*/, ">>=");
           return this.advance();
+          $throw(new FallThroughError("./leg/scanner/scanner.dart", 392))
 
         case 62/*null.$GT*/:
 
           return this.select(61/*null.$EQ*/, ">>>=", ">>>");
+          $throw(new FallThroughError("./leg/scanner/scanner.dart", 394))
 
         default:
 
           this.appendStringToken(62/*null.$GT*/, ">>");
           return next;
 
       }
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 389))
 
     default:
 
       this.appendStringToken(62/*null.$GT*/, ">");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeLessThan = function(next) {
   next = this.advance();
   switch (next) {
     case 61/*null.$EQ*/:
 
       this.appendStringToken(60/*null.$LT*/, "<=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 411))
 
     case 60/*null.$LT*/:
 
       return this.select(61/*null.$EQ*/, "<<=", "<<");
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 413))
 
     default:
 
       this.appendStringToken(60/*null.$LT*/, "<");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeNumber = function(next) {
   var start = this.get$byteOffset();
   while (true) {
     next = this.advance();
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 435))
 
       case 46/*null.$PERIOD*/:
 
         return this.tokenizeFractionPart(this.advance(), start);
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 438))
 
       case 101/*null.$e*/:
       case 69/*null.$E*/:
       case 100/*null.$d*/:
       case 68/*null.$D*/:
 
         return this.tokenizeFractionPart(next, start);
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 444))
 
       default:
 
         this.appendByteStringToken(105/*null.$i*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 AbstractScanner.prototype.tokenizeHexOrNumber = function(next) {
@@ skipping 28 matching lines @@
       case 70/*null.$F*/:
       case 97/*null.$a*/:
       case 98/*null.$b*/:
       case 99/*null.$c*/:
       case 100/*null.$d*/:
       case 101/*null.$e*/:
       case 102/*null.$f*/:
 
         hasDigits = true;
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 491))
 
       default:
 
         if (!hasDigits) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         this.appendByteStringToken(120/*null.$x*/, this.asciiString(start));
         return next;
 
     }
@@ skipping 10 matching lines @@
     case 52/*null.$4*/:
     case 53/*null.$5*/:
     case 54/*null.$6*/:
     case 55/*null.$7*/:
     case 56/*null.$8*/:
     case 57/*null.$9*/:
 
       {
         return this.tokenizeFractionPart(next, start);
       }
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 516))
 
     case 46/*null.$PERIOD*/:
 
       return this.select(46/*null.$PERIOD*/, "...", "..");
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 521))
 
     default:
 
       this.appendStringToken(46/*null.$PERIOD*/, ".");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
   while (!done) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 543))
 
       case 101/*null.$e*/:
       case 69/*null.$E*/:
 
         next = this.tokenizeExponent(this.advance());
         done = true;
         continue LOOP;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 549))
 
       default:
 
         done = true;
         continue LOOP;
 
     }
     next = this.advance();
   }
   if (next == 100/*null.$d*/ || next == 68/*null.$D*/) {
@@ skipping 15 matching lines @@
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         hasDigits = true;
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 582))
 
       default:
 
         if (!hasDigits) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         return next;
 
     }
     next = this.advance();
   }
 }
 AbstractScanner.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
   switch (next) {
     case 42/*null.$STAR*/:
 
       return this.tokenizeMultiLineComment(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 598))
 
     case 47/*null.$SLASH*/:
 
       return this.tokenizeSingleLineComment(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 601))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(47/*null.$SLASH*/, "/=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 605))
 
     default:
 
       this.appendStringToken(47/*null.$SLASH*/, "/");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeSingleLineComment = function(next) {
   while (true) {
     next = this.advance();
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
       case 10/*null.$LF*/:
       case 13/*null.$CR*/:
 
         return next;
 
     }
   }
 }
 AbstractScanner.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
   while (true) {
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
 
         return next;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 630))
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
         if (next == 47/*null.$SLASH*/) {
           return this.advance();
         }
-        else if (next == -1) {
+        else if (next == -1.000000/*-1*/) {
           return next;
         }
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 638))
 
       default:
 
         next = this.advance();
         break;
 
     }
   }
 }
 AbstractScanner.prototype.tokenizeIdentifier = function(next) {
@@ skipping 14 matching lines @@
       state = null;
     }
     else if (next < 128) {
       if (state != null && state.isLeaf()) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if (isAscii) {
         this.appendByteStringToken(97/*null.$a*/, this.asciiString(start));
       }
       else {
-        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1));
+        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1.000000/*-1*/));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.get$byteOffset();
       do {
         next = this.nextByte();
       }
       while (next > 127)
-      var string = this.utf8String(nonAsciiStart, -1).toString();
+      var string = this.utf8String(nonAsciiStart, -1.000000/*-1*/).toString();
       isAscii = false;
       this.addToCharOffset(string.length);
       return next;
     }
     next = this.advance();
   }
 }
 AbstractScanner.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.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(q, this.utf8String(start, -1));
+      this.appendByteStringToken(q, this.utf8String(start, -1.000000/*-1*/));
       return next;
     }
   }
   if (raw) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
 AbstractScanner.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next == 92/*null.$BACKSLASH*/) {
       next = this.advance();
-      if (next == -1) {
+      if (next == -1.000000/*-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.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, 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.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q) {
       next = this.advance();
       if (next == q) {
         next = this.advance();
         if (next == q) {
           this.appendByteStringToken(q, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for AbstractScanner$S **************
 function AbstractScanner$S() {}
 $inherits(AbstractScanner$S, AbstractScanner);
 AbstractScanner$S.prototype.tokenize = function() {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     next = this.bigSwitch(next);
   }
   return this.firstToken();
 }
 AbstractScanner$S.prototype.bigSwitch = function(next) {
   this.beginToken();
   switch (next) {
     case 9/*null.$TAB*/:
     case 10/*null.$LF*/:
     case 13/*null.$CR*/:
     case 32/*null.$SPACE*/:
 
       this.appendWhiteSpace(next);
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 62))
 
     case 60/*null.$LT*/:
 
       return this.tokenizeLessThan(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 65))
 
     case 62/*null.$GT*/:
 
       return this.tokenizeGreaterThan(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 68))
 
     case 61/*null.$EQ*/:
 
       return this.tokenizeEquals(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 71))
 
     case 33/*null.$BANG*/:
 
       return this.tokenizeExclamation(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 74))
 
     case 43/*null.$PLUS*/:
 
       return this.tokenizePlus(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 77))
 
     case 45/*null.$MINUS*/:
 
       return this.tokenizeMinus(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 80))
 
     case 42/*null.$STAR*/:
 
       return this.tokenizeMultiply(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 83))
 
     case 37/*null.$PERCENT*/:
 
       return this.tokenizePercent(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 86))
 
     case 38/*null.$AMPERSAND*/:
 
       return this.tokenizeAmpersand(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 89))
 
     case 124/*null.$BAR*/:
 
       return this.tokenizeBar(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 92))
 
     case 94/*null.$CARET*/:
 
       return this.tokenizeCaret(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 95))
 
     case 91/*null.$LBRACKET*/:
 
       return this.tokenizeOpenBracket(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 98))
 
     case 126/*null.$TILDE*/:
 
       return this.tokenizeTilde(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 101))
 
     case 92/*null.$BACKSLASH*/:
 
       this.appendStringToken(next, "\\");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 105))
 
     case 35/*null.$HASH*/:
 
       return this.tokenizeTag(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 108))
 
     case 40/*null.$LPAREN*/:
 
       this.appendStringToken(next, "(");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 112))
 
     case 41/*null.$RPAREN*/:
 
       this.appendStringToken(next, ")");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 116))
 
     case 44/*null.$COMMA*/:
 
       this.appendStringToken(next, ",");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 120))
 
     case 58/*null.$COLON*/:
 
       this.appendStringToken(next, ":");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 124))
 
     case 59/*null.$SEMICOLON*/:
 
       this.appendStringToken(next, ";");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 128))
 
     case 63/*null.$QUESTION*/:
 
       this.appendStringToken(next, "?");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 132))
 
     case 93/*null.$RBRACKET*/:
 
       this.appendStringToken(next, "]");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 136))
 
     case 96/*null.$BACKPING*/:
 
       this.appendStringToken(next, "`");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 140))
 
     case 123/*null.$LBRACE*/:
 
       this.appendStringToken(next, "{");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 144))
 
     case 125/*null.$RBRACE*/:
 
       this.appendStringToken(next, "}");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 148))
 
     case 47/*null.$SLASH*/:
 
       return this.tokenizeSlashOrComment(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 151))
 
     case 64/*null.$AT*/:
 
       return this.tokenizeRawString(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 154))
 
     case 34/*null.$DQ*/:
     case 39/*null.$SQ*/:
 
       return this.tokenizeString(next, this.get$byteOffset(), false);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 158))
 
     case 46/*null.$PERIOD*/:
 
       return this.tokenizeDotOrNumber(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 161))
 
     case 48/*null.$0*/:
 
       return this.tokenizeHexOrNumber(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 164))
 
     case 49/*null.$1*/:
     case 50/*null.$2*/:
     case 51/*null.$3*/:
     case 52/*null.$4*/:
     case 53/*null.$5*/:
     case 54/*null.$6*/:
     case 55/*null.$7*/:
     case 56/*null.$8*/:
     case 57/*null.$9*/:
 
       return this.tokenizeNumber(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 175))
 
     case 36/*null.$DOLLAR*/:
     case 65/*null.$A*/:
     case 66/*null.$B*/:
     case 67/*null.$C*/:
     case 68/*null.$D*/:
     case 69/*null.$E*/:
     case 70/*null.$F*/:
     case 71/*null.$G*/:
     case 72/*null.$H*/:
@@ skipping 37 matching lines @@
     case 115/*null.$s*/:
     case 116/*null.$t*/:
     case 117/*null.$u*/:
     case 118/*null.$v*/:
     case 119/*null.$w*/:
     case 120/*null.$x*/:
     case 121/*null.$y*/:
     case 122/*null.$z*/:
 
       return this.tokenizeIdentifier(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 231))
 
     default:
 
-      if (next == -1) {
-        return -1;
+      if (next == -1.000000/*-1*/) {
+        return -1.000000/*-1*/;
       }
       if (next < 0x1f) {
         $throw(this.get$charOffset());
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 AbstractScanner$S.prototype.tokenizeTag = function(next) {
@@ skipping 32 matching lines @@
 AbstractScanner$S.prototype.tokenizeCaret = function(next) {
   return this.select(61/*null.$EQ*/, "^=", "^");
 }
 AbstractScanner$S.prototype.tokenizeBar = function(next) {
   next = this.advance();
   switch (next) {
     case 124/*null.$BAR*/:
 
       this.appendStringToken(124/*null.$BAR*/, "||");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 292))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(124/*null.$BAR*/, "|=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 295))
 
     default:
 
       this.appendStringToken(124/*null.$BAR*/, "|");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeAmpersand = function(next) {
   next = this.advance();
   switch (next) {
     case 38/*null.$AMPERSAND*/:
 
       this.appendStringToken(38/*null.$AMPERSAND*/, "&&");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 308))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(38/*null.$AMPERSAND*/, "&=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 311))
 
     default:
 
       this.appendStringToken(38/*null.$AMPERSAND*/, "&");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizePercent = function(next) {
   return this.select(61/*null.$EQ*/, "%=", "%");
 }
 AbstractScanner$S.prototype.tokenizeMultiply = function(next) {
   return this.select(61/*null.$EQ*/, "*=", "*");
 }
 AbstractScanner$S.prototype.tokenizeMinus = function(next) {
   next = this.advance();
   switch (next) {
     case 45/*null.$MINUS*/:
 
       this.appendStringToken(45/*null.$MINUS*/, "--");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 334))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(45/*null.$MINUS*/, "-=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 337))
 
     default:
 
       this.appendStringToken(45/*null.$MINUS*/, "-");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizePlus = function(next) {
   next = this.advance();
   switch (next) {
     case 43/*null.$PLUS*/:
 
       this.appendStringToken(43/*null.$PLUS*/, "++");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 350))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(43/*null.$PLUS*/, "+=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 353))
 
     default:
 
       this.appendStringToken(43/*null.$PLUS*/, "+");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeExclamation = function(next) {
   next = this.advance();
@@ skipping 11 matching lines @@
   this.appendStringToken(61/*null.$EQ*/, "=");
   return next;
 }
 AbstractScanner$S.prototype.tokenizeGreaterThan = function(next) {
   next = this.advance();
   switch (next) {
     case 61/*null.$EQ*/:
 
       this.appendStringToken(62/*null.$GT*/, ">=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 386))
 
     case 62/*null.$GT*/:
 
       next = this.advance();
       switch (next) {
         case 61/*null.$EQ*/:
 
           this.appendStringToken(62/*null.$GT*/, ">>=");
           return this.advance();
+          $throw(new FallThroughError("./leg/scanner/scanner.dart", 392))
 
         case 62/*null.$GT*/:
 
           return this.select(61/*null.$EQ*/, ">>>=", ">>>");
+          $throw(new FallThroughError("./leg/scanner/scanner.dart", 394))
 
         default:
 
           this.appendStringToken(62/*null.$GT*/, ">>");
           return next;
 
       }
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 389))
 
     default:
 
       this.appendStringToken(62/*null.$GT*/, ">");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeLessThan = function(next) {
   next = this.advance();
   switch (next) {
     case 61/*null.$EQ*/:
 
       this.appendStringToken(60/*null.$LT*/, "<=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 411))
 
     case 60/*null.$LT*/:
 
       return this.select(61/*null.$EQ*/, "<<=", "<<");
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 413))
 
     default:
 
       this.appendStringToken(60/*null.$LT*/, "<");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeNumber = function(next) {
   var start = this.get$byteOffset();
   while (true) {
     next = this.advance();
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 435))
 
       case 46/*null.$PERIOD*/:
 
         return this.tokenizeFractionPart(this.advance(), start);
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 438))
 
       case 101/*null.$e*/:
       case 69/*null.$E*/:
       case 100/*null.$d*/:
       case 68/*null.$D*/:
 
         return this.tokenizeFractionPart(next, start);
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 444))
 
       default:
 
         this.appendByteStringToken(105/*null.$i*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 AbstractScanner$S.prototype.tokenizeHexOrNumber = function(next) {
@@ skipping 28 matching lines @@
       case 70/*null.$F*/:
       case 97/*null.$a*/:
       case 98/*null.$b*/:
       case 99/*null.$c*/:
       case 100/*null.$d*/:
       case 101/*null.$e*/:
       case 102/*null.$f*/:
 
         hasDigits = true;
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 491))
 
       default:
 
         if (!hasDigits) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         this.appendByteStringToken(120/*null.$x*/, this.asciiString(start));
         return next;
 
     }
@@ skipping 10 matching lines @@
     case 52/*null.$4*/:
     case 53/*null.$5*/:
     case 54/*null.$6*/:
     case 55/*null.$7*/:
     case 56/*null.$8*/:
     case 57/*null.$9*/:
 
       {
         return this.tokenizeFractionPart(next, start);
       }
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 516))
 
     case 46/*null.$PERIOD*/:
 
       return this.select(46/*null.$PERIOD*/, "...", "..");
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 521))
 
     default:
 
       this.appendStringToken(46/*null.$PERIOD*/, ".");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
   while (!done) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 543))
 
       case 101/*null.$e*/:
       case 69/*null.$E*/:
 
         next = this.tokenizeExponent(this.advance());
         done = true;
         continue LOOP;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 549))
 
       default:
 
         done = true;
         continue LOOP;
 
     }
     next = this.advance();
   }
   if (next == 100/*null.$d*/ || next == 68/*null.$D*/) {
@@ skipping 15 matching lines @@
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         hasDigits = true;
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 582))
 
       default:
 
         if (!hasDigits) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         return next;
 
     }
     next = this.advance();
   }
 }
 AbstractScanner$S.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
   switch (next) {
     case 42/*null.$STAR*/:
 
       return this.tokenizeMultiLineComment(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 598))
 
     case 47/*null.$SLASH*/:
 
       return this.tokenizeSingleLineComment(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 601))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(47/*null.$SLASH*/, "/=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 605))
 
     default:
 
       this.appendStringToken(47/*null.$SLASH*/, "/");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeSingleLineComment = function(next) {
   while (true) {
     next = this.advance();
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
       case 10/*null.$LF*/:
       case 13/*null.$CR*/:
 
         return next;
 
     }
   }
 }
 AbstractScanner$S.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
   while (true) {
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
 
         return next;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 630))
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
         if (next == 47/*null.$SLASH*/) {
           return this.advance();
         }
-        else if (next == -1) {
+        else if (next == -1.000000/*-1*/) {
           return next;
         }
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 638))
 
       default:
 
         next = this.advance();
         break;
 
     }
   }
 }
 AbstractScanner$S.prototype.tokenizeIdentifier = function(next) {
@@ skipping 14 matching lines @@
       state = null;
     }
     else if (next < 128) {
       if (state != null && state.isLeaf()) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if (isAscii) {
         this.appendByteStringToken(97/*null.$a*/, this.asciiString(start));
       }
       else {
-        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1));
+        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1.000000/*-1*/));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.get$byteOffset();
       do {
         next = this.nextByte();
       }
       while (next > 127)
-      var string = this.utf8String(nonAsciiStart, -1).toString();
+      var string = this.utf8String(nonAsciiStart, -1.000000/*-1*/).toString();
       isAscii = false;
       this.addToCharOffset(string.length);
       return next;
     }
     next = this.advance();
   }
 }
 AbstractScanner$S.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 q = next;
   next = this.advance();
   if (q == next) {
     next = this.advance();
     if (q == next) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
-      this.appendByteStringToken(q, this.utf8String(start, -1));
+      this.appendByteStringToken(q, this.utf8String(start, -1.000000/*-1*/));
       return next;
     }
   }
   if (raw) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
 AbstractScanner$S.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next == 92/*null.$BACKSLASH*/) {
       next = this.advance();
-      if (next == -1) {
+      if (next == -1.000000/*-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) {
   next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, 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 next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q) {
       next = this.advance();
       if (next == q) {
         next = this.advance();
         if (next == q) {
           this.appendByteStringToken(q, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for MalformedInputException **************
 function MalformedInputException(ignored) {
   // Initializers done
 }
-// ********** Code for Parser **************
-function Parser(listener) {
+// ********** Code for scanner_Parser **************
+function scanner_Parser(listener) {
   this.listener = listener;
   // Initializers done
 }
-Parser.prototype.next = function(token) {
+scanner_Parser.prototype.next = function(token) {
   return this.checkEof(token.next);
 }
-Parser.prototype.checkEof = function(token) {
+scanner_Parser.prototype.checkEof = function(token) {
   if (token == null) {
     this.listener.unexpectedEof();
     $throw("Unexpected EOF");
   }
   return token;
 }
-Parser.prototype.parseUnit = function(token) {
+scanner_Parser.prototype.parseUnit = function(token) {
   while (token != null) {
     switch (token.get$value()) {
-      case const$305/*Keyword.INTERFACE*/:
+      case const$297/*Keyword.INTERFACE*/:
 
         token = this.parseInterface(token);
         break;
+        $throw(new FallThroughError("./leg/scanner/parser.dart", 28))
 
-      case const$293/*Keyword.CLASS*/:
+      case const$285/*Keyword.CLASS*/:
 
         token = this.parseClass(token);
         break;
+        $throw(new FallThroughError("./leg/scanner/parser.dart", 31))
 
-      case const$321/*Keyword.TYPEDEF*/:
+      case const$313/*Keyword.TYPEDEF*/:
 
         token = this.parseNamedFunctionAlias(token);
         break;
+        $throw(new FallThroughError("./leg/scanner/parser.dart", 34))
 
       case "#":
 
         token = this.parseLibraryTags(token);
         break;
+        $throw(new FallThroughError("./leg/scanner/parser.dart", 37))
 
       default:
 
         token = this.parseTopLevelMember(token);
         break;
 
     }
   }
 }
-Parser.prototype.parseInterface = function(token) {
+scanner_Parser.prototype.parseInterface = function(token) {
   this.listener.beginInterface(token);
   token = this.parseIdentifier(this.next(token));
   token = this.parseTypeVariablesOpt(token);
   token = this.parseSupertypesClauseOpt(token);
   token = this.parseFactoryClauseOpt(token);
   return this.parseInterfaceBody(token);
 }
-Parser.prototype.parseInterfaceBody = function(token) {
+scanner_Parser.prototype.parseInterfaceBody = function(token) {
   token = this.skipBlock(token);
   this.listener.endInterface(token);
   return token.next;
 }
-Parser.prototype.parseNamedFunctionAlias = function(token) {
+scanner_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(";", token);
 }
-Parser.prototype.parseReturnTypeOpt = function(token) {
-  if ($eq(token.get$value(), const$285/*Keyword.VOID*/)) {
+scanner_Parser.prototype.parseReturnTypeOpt = function(token) {
+  if ($eq(token.get$value(), const$277/*Keyword.VOID*/)) {
     return this.next(token);
   }
   else {
     return this.parseTypeOpt(token);
   }
 }
-Parser.prototype.parseParameters = function(token) {
+scanner_Parser.prototype.parseParameters = function(token) {
   this.expect("(", token);
   if (this.optional(")", this.next(token))) {
     return this.next(this.next(token));
   }
   do {
     token = this.parseTypeOpt(this.next(token));
     token = this.parseIdentifier(token);
   }
   while (this.optional(",", token))
   return this.expect(")", token);
 }
-Parser.prototype.parseTypeOpt = function(token) {
+scanner_Parser.prototype.parseTypeOpt = function(token) {
   switch (true) {
     case this.optional("<", this.next(token)):
     case this.optional(".", this.next(token)):
     case this.isIdentifier(this.next(token)):
 
       return this.parseType(token);
+      $throw(new FallThroughError("./leg/scanner/parser.dart", 96))
 
     default:
 
       return token;
 
   }
 }
-Parser.prototype.isIdentifier = function(token) {
+scanner_Parser.prototype.isIdentifier = function(token) {
   switch (token.kind) {
     case 97/*null.$a*/:
 
       return true;
+      $throw(new FallThroughError("./leg/scanner/parser.dart", 105))
 
     case 107/*null.$k*/:
 
       return token.get$value().isPseudo;
+      $throw(new FallThroughError("./leg/scanner/parser.dart", 107))
 
     default:
 
       return false;
 
   }
 }
-Parser.prototype.parseSupertypesClauseOpt = function(token) {
-  if (this.optional(const$295/*Keyword.EXTENDS*/, token)) {
+scanner_Parser.prototype.parseSupertypesClauseOpt = function(token) {
+  if (this.optional(const$287/*Keyword.EXTENDS*/, token)) {
     do {
       token = this.parseType(this.next(token));
     }
     while (this.optional(",", token))
   }
   return token;
 }
-Parser.prototype.parseFactoryClauseOpt = function(token) {
-  if (this.optional(const$297/*Keyword.FACTORY*/, token)) {
+scanner_Parser.prototype.parseFactoryClauseOpt = function(token) {
+  if (this.optional(const$289/*Keyword.FACTORY*/, token)) {
     return this.parseType(this.next(token));
   }
   return token;
 }
-Parser.prototype.skipBlock = function(token) {
+scanner_Parser.prototype.skipBlock = function(token) {
   if (!this.optional("{", token)) return this.listener.expectedBlock(token);
   token = this.next(token);
   var nesting = 1;
   do {
     switch (token.kind) {
       case 123/*null.$LBRACE*/:
 
         nesting++;
         break;
+        $throw(new FallThroughError("./leg/scanner/parser.dart", 137))
 
       case 125/*null.$RBRACE*/:
 
         nesting--;
         if (nesting == 0) {
           return token;
         }
         break;
 
     }
     token = this.next(token);
   }
   while (token != null)
   $throw("Internal error: unreachable code");
 }
-Parser.prototype.parseClass = function(token) {
+scanner_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$309/*Keyword.NATIVE*/, token)) {
+scanner_Parser.prototype.parseNativeClassClauseOpt = function(token) {
+  if (this.optional(const$301/*Keyword.NATIVE*/, token)) {
     return this.parseString(this.next(token));
   }
   return token;
 }
-Parser.prototype.parseString = function(token) {
+scanner_Parser.prototype.parseString = function(token) {
   switch (token.kind) {
     case 39/*null.$SQ*/:
     case 34/*null.$DQ*/:
 
       return this.next(token);
+      $throw(new FallThroughError("./leg/scanner/parser.dart", 171))
 
     default:
 
       return this.listener.expected("string", token);
 
   }
 }
-Parser.prototype.parseIdentifier = function(token) {
+scanner_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) {
+scanner_Parser.prototype.parseTypeVariablesOpt = function(token) {
   if (!this.optional("<", token)) {
     return token;
   }
   this.listener.beginTypeVariables(token);
   do {
     token = this.parseTypeVariable(this.next(token));
   }
   while (this.optional(",", token))
   return this.expect(">", token);
 }
-Parser.prototype.expect = function(string, token) {
+scanner_Parser.prototype.expect = function(string, token) {
   if (string != token.get$value()) {
     return this.listener.expected(string, token);
   }
   return token.next;
 }
-Parser.prototype.parseTypeVariable = function(token) {
+scanner_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) {
+scanner_Parser.prototype.optional = function(value, token) {
   return $eq(value, token.get$value());
 }
-Parser.prototype.parseSuperclassClauseOpt = function(token) {
-  if (this.optional(const$295/*Keyword.EXTENDS*/, token)) {
+scanner_Parser.prototype.parseSuperclassClauseOpt = function(token) {
+  if (this.optional(const$287/*Keyword.EXTENDS*/, token)) {
     return this.parseType(this.next(token));
   }
   return token;
 }
-Parser.prototype.parseType = function(token) {
+scanner_Parser.prototype.parseType = function(token) {
   if (this.isIdentifier(token)) {
     token = this.parseIdentifier(token);
   }
   else {
     token = this.listener.expectedType(token);
   }
   return this.parseTypeArgumentsOpt(token);
 }
-Parser.prototype.parseTypeArgumentsOpt = function(token) {
+scanner_Parser.prototype.parseTypeArgumentsOpt = function(token) {
   if (this.optional("<", token)) {
     this.listener.beginTypeArguments(this.next(token));
     do {
       token = this.parseType(this.next(token));
     }
     while (this.optional(",", token))
     return this.expect(">", token);
   }
   return token;
 }
-Parser.prototype.parseImplementsOpt = function(token) {
-  if (this.optional(const$301/*Keyword.IMPLEMENTS*/, token)) {
+scanner_Parser.prototype.parseImplementsOpt = function(token) {
+  if (this.optional(const$293/*Keyword.IMPLEMENTS*/, token)) {
     do {
       token = this.parseType(this.next(token));
     }
     while (this.optional(",", token))
   }
   return token;
 }
-Parser.prototype.parseClassBody = function(token) {
+scanner_Parser.prototype.parseClassBody = function(token) {
   token = this.skipBlock(token);
   this.listener.endClass(token);
   return token.next;
 }
-Parser.prototype.parseTopLevelMember = function(token) {
+scanner_Parser.prototype.parseTopLevelMember = function(token) {
   var start = token;
   this.listener.beginTopLevelMember(token);
   var previous = token;
   LOOP:
   while (token != null) {
     switch (token.kind) {
       case 123/*null.$LBRACE*/:
       case 59/*null.$SEMICOLON*/:
       case 40/*null.$LPAREN*/:
       case 61/*null.$EQ*/:
 
         break LOOP;
+        $throw(new FallThroughError("./leg/scanner/parser.dart", 266))
 
       default:
 
         token = this.next(previous = token);
         break;
 
     }
   }
   token = this.parseIdentifier(previous);
   if (this.optional("(", token)) {
     this.listener.topLevelMethod(start);
   }
   else if (this.optional("=", token) || this.optional(";", token)) {
     this.listener.topLevelField(start);
   }
   else {
     token = this.listener.unexpected(token);
   }
   while (token != null && token.kind != 123/*null.$LBRACE*/ && token.kind != 59/*null.$SEMICOLON*/) {
     token = this.next(token);
   }
   if (!this.optional(";", token)) {
     token = this.skipBlock(token);
   }
   this.listener.endTopLevelMember(token);
   return token.next;
 }
-Parser.prototype.parseLibraryTags = function(token) {
+scanner_Parser.prototype.parseLibraryTags = function(token) {
   this.listener.beginLibraryTag(token);
   token = this.parseIdentifier(this.next(token));
   token = this.expect("(", token);
   while (token != null && token.kind != 40/*null.$LPAREN*/ && token.kind != 41/*null.$RPAREN*/) {
     token = this.next(token);
   }
   token = this.expect(")", token);
   return this.expect(";", token);
 }
 // ********** Code for Listener **************
@@ skipping 47 matching lines @@
 Listener.prototype.beginTypeVariable = function(token) {
 
 }
 Listener.prototype.endTypeVariable = function(token) {
 
 }
 Listener.prototype.beginTypeVariables = function(token) {
 
 }
 Listener.prototype.identifier = function(token) {
-  this.previousIdentifier = new Identifier(token);
+  this.previousIdentifier = new tree_Identifier(token);
 }
 Listener.prototype.beginTypeArguments = function(token) {
 
 }
 Listener.prototype.expected = function(string, token) {
   $throw(("Expected '" + string + "', but got '" + token + "' @ " + token.charOffset + ""));
 }
 Listener.prototype.unexpectedEof = function() {
   $throw("Unexpected end of file");
 }
@@ skipping 60 matching lines @@
   // Initializers done
 }
 $inherits(StringScanner, ArrayBasedScanner$String);
 StringScanner.prototype.nextByte = function() {
   return this.charAt(++this.byteOffset);
 }
 StringScanner.prototype.peek = function() {
   return this.charAt(this.byteOffset + 1);
 }
 StringScanner.prototype.charAt = function(index) {
-  return (this.string.length > index) ? this.string.charCodeAt(index) : -1;
+  return (this.string.length > index) ? this.string.charCodeAt(index) : -1.000000/*-1*/;
 }
 StringScanner.prototype.asciiString = function(start) {
   return this.string.substring(start, this.byteOffset);
 }
 StringScanner.prototype.utf8String = function(start, offset) {
   return this.string.substring(start, this.byteOffset + offset + 1);
 }
 StringScanner.prototype.appendByteStringToken = function(kind, value) {
   this.tail.next = new StringToken(kind, value, this.tokenStart);
   this.tail = this.tail.next;
 }
 // ********** Code for top level **************
 //  ********** Library scanner_implementation **************
 // ********** Code for Keyword **************
 function Keyword(syntax, isPseudo) {
   this.syntax = syntax;
   this.isPseudo = isPseudo;
   // Initializers done
 }
 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 $i = 0;$i < const$323/*Keyword.values*/.length; $i++) {
-    var keyword = const$323/*Keyword.values*/.$index($i);
+  for (var $i = 0;$i < const$315/*Keyword.values*/.length; $i++) {
+    var keyword = const$315/*Keyword.values*/.$index($i);
     result.$setindex(keyword.syntax, keyword);
   }
   return result;
 }
 // ********** Code for KeywordState **************
 function KeywordState() {}
 KeywordState.get$KEYWORD_STATE = function() {
   if (KeywordState._KEYWORD_STATE == null) {
-    var strings = new ListFactory$String(const$323/*Keyword.values*/.length);
+    var strings = new ListFactory$String(const$315/*Keyword.values*/.length);
     for (var i = 0;
-     i < const$323/*Keyword.values*/.length; i++) {
-      strings.$setindex(i, const$323/*Keyword.values*/.$index(i).syntax);
+     i < const$315/*Keyword.values*/.length; i++) {
+      strings.$setindex(i, const$315/*Keyword.values*/.$index(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) {
   var result = new ListFactory$KeywordState(26);
   var chunk = 0;
-  var chunkStart = -1;
+  var chunkStart = -1.000000/*-1*/;
   for (var i = offset;
    i < offset + length; i++) {
     if (strings.$index(i).length > start) {
       var c = strings.$index(i).charCodeAt(start);
       if (chunk != c) {
-        if (chunkStart != -1) {
+        if (chunkStart != -1.000000/*-1*/) {
           result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart));
         }
         chunkStart = i;
         chunk = c;
       }
     }
   }
-  if (chunkStart != -1) {
+  if (chunkStart != -1.000000/*-1*/) {
     result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, offset + length - chunkStart));
   }
   else {
     return new LeafKeywordState(strings.$index(offset));
   }
   return new ArrayKeywordState(result);
 }
 // ********** Code for ArrayKeywordState **************
 function ArrayKeywordState(table) {
   this.table = table;
@@ skipping 32 matching lines @@
 LeafKeywordState.prototype.set$keyword = function(value) { return this.keyword = value; };
 LeafKeywordState.prototype.isLeaf = function() {
   return true;
 }
 LeafKeywordState.prototype.next = function(c) {
   return null;
 }
 LeafKeywordState.prototype.toString = function() {
   return this.keyword.syntax;
 }
-// ********** Code for Token **************
-function Token(kind, charOffset) {
+// ********** Code for scanner_implementation_Token **************
+function scanner_implementation_Token(kind, charOffset) {
   this.kind = kind;
   this.charOffset = charOffset;
   // Initializers done
 }
-Token.prototype.toString = function() {
+scanner_implementation_Token.prototype.toString = function() {
   return Strings.String$fromCharCodes$factory([this.kind]);
 }
 // ********** Code for KeywordToken **************
 function KeywordToken(value, charOffset) {
   this.value = value;
-  Token.call(this, 107/*null.$k*/, charOffset);
+  scanner_implementation_Token.call(this, 107/*null.$k*/, charOffset);
   // Initializers done
 }
-$inherits(KeywordToken, Token);
+$inherits(KeywordToken, scanner_implementation_Token);
 KeywordToken.prototype.get$value = function() { return this.value; };
 KeywordToken.prototype.toString = function() {
   return this.value.syntax;
 }
 // ********** Code for StringToken **************
 function StringToken(kind, value, charOffset) {
   this.value = value;
-  Token.call(this, kind, charOffset);
+  scanner_implementation_Token.call(this, kind, charOffset);
   // Initializers done
 }
-$inherits(StringToken, Token);
+$inherits(StringToken, scanner_implementation_Token);
 StringToken.prototype.get$value = function() { return this.value; };
 StringToken.prototype.toString = function() {
   return this.value;
 }
 // ********** Code for ArrayBasedScanner **************
 function ArrayBasedScanner() {
-  this.charOffset = -1;
-  this.tokenStart = -1;
-  this.byteOffset = -1;
-  this.tokens = new Token(0, -1);
+  this.charOffset = -1.000000/*-1*/;
+  this.tokenStart = -1.000000/*-1*/;
+  this.byteOffset = -1.000000/*-1*/;
+  this.tokens = new scanner_implementation_Token(0, -1.000000/*-1*/);
   // Initializers done
   this.tail = this.tokens;
 }
 $inherits(ArrayBasedScanner, AbstractScanner$S);
 ArrayBasedScanner.prototype.get$charOffset = function() { return this.charOffset; };
 ArrayBasedScanner.prototype.set$charOffset = function(value) { return this.charOffset = value; };
 ArrayBasedScanner.prototype.get$byteOffset = function() { return this.byteOffset; };
 ArrayBasedScanner.prototype.set$byteOffset = function(value) { return this.byteOffset = value; };
 ArrayBasedScanner.prototype.advance = function() {
   var next = this.nextByte();
@@ skipping 26 matching lines @@
   return this.tokens.next;
 }
 ArrayBasedScanner.prototype.addToCharOffset = function(offset) {
   this.charOffset += offset;
 }
 ArrayBasedScanner.prototype.appendWhiteSpace = function(next) {
 
 }
 // ********** Code for ArrayBasedScanner$String **************
 function ArrayBasedScanner$String() {
-  this.charOffset = -1;
-  this.tokenStart = -1;
-  this.byteOffset = -1;
-  this.tokens = new Token(0, -1);
+  this.charOffset = -1.000000/*-1*/;
+  this.tokenStart = -1.000000/*-1*/;
+  this.byteOffset = -1.000000/*-1*/;
+  this.tokens = new scanner_implementation_Token(0, -1.000000/*-1*/);
   // Initializers done
   this.tail = this.tokens;
 }
 $inherits(ArrayBasedScanner$String, ArrayBasedScanner);
 ArrayBasedScanner$String.prototype.tokenize = function() {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     next = this.bigSwitch(next);
   }
   return this.firstToken();
 }
 ArrayBasedScanner$String.prototype.bigSwitch = function(next) {
   this.beginToken();
   switch (next) {
     case 9/*null.$TAB*/:
     case 10/*null.$LF*/:
     case 13/*null.$CR*/:
     case 32/*null.$SPACE*/:
 
       this.appendWhiteSpace(next);
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 62))
 
     case 60/*null.$LT*/:
 
       return this.tokenizeLessThan(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 65))
 
     case 62/*null.$GT*/:
 
       return this.tokenizeGreaterThan(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 68))
 
     case 61/*null.$EQ*/:
 
       return this.tokenizeEquals(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 71))
 
     case 33/*null.$BANG*/:
 
       return this.tokenizeExclamation(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 74))
 
     case 43/*null.$PLUS*/:
 
       return this.tokenizePlus(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 77))
 
     case 45/*null.$MINUS*/:
 
       return this.tokenizeMinus(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 80))
 
     case 42/*null.$STAR*/:
 
       return this.tokenizeMultiply(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 83))
 
     case 37/*null.$PERCENT*/:
 
       return this.tokenizePercent(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 86))
 
     case 38/*null.$AMPERSAND*/:
 
       return this.tokenizeAmpersand(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 89))
 
     case 124/*null.$BAR*/:
 
       return this.tokenizeBar(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 92))
 
     case 94/*null.$CARET*/:
 
       return this.tokenizeCaret(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 95))
 
     case 91/*null.$LBRACKET*/:
 
       return this.tokenizeOpenBracket(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 98))
 
     case 126/*null.$TILDE*/:
 
       return this.tokenizeTilde(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 101))
 
     case 92/*null.$BACKSLASH*/:
 
       this.appendStringToken(next, "\\");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 105))
 
     case 35/*null.$HASH*/:
 
       return this.tokenizeTag(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 108))
 
     case 40/*null.$LPAREN*/:
 
       this.appendStringToken(next, "(");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 112))
 
     case 41/*null.$RPAREN*/:
 
       this.appendStringToken(next, ")");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 116))
 
     case 44/*null.$COMMA*/:
 
       this.appendStringToken(next, ",");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 120))
 
     case 58/*null.$COLON*/:
 
       this.appendStringToken(next, ":");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 124))
 
     case 59/*null.$SEMICOLON*/:
 
       this.appendStringToken(next, ";");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 128))
 
     case 63/*null.$QUESTION*/:
 
       this.appendStringToken(next, "?");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 132))
 
     case 93/*null.$RBRACKET*/:
 
       this.appendStringToken(next, "]");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 136))
 
     case 96/*null.$BACKPING*/:
 
       this.appendStringToken(next, "`");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 140))
 
     case 123/*null.$LBRACE*/:
 
       this.appendStringToken(next, "{");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 144))
 
     case 125/*null.$RBRACE*/:
 
       this.appendStringToken(next, "}");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 148))
 
     case 47/*null.$SLASH*/:
 
       return this.tokenizeSlashOrComment(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 151))
 
     case 64/*null.$AT*/:
 
       return this.tokenizeRawString(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 154))
 
     case 34/*null.$DQ*/:
     case 39/*null.$SQ*/:
 
       return this.tokenizeString(next, this.byteOffset, false);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 158))
 
     case 46/*null.$PERIOD*/:
 
       return this.tokenizeDotOrNumber(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 161))
 
     case 48/*null.$0*/:
 
       return this.tokenizeHexOrNumber(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 164))
 
     case 49/*null.$1*/:
     case 50/*null.$2*/:
     case 51/*null.$3*/:
     case 52/*null.$4*/:
     case 53/*null.$5*/:
     case 54/*null.$6*/:
     case 55/*null.$7*/:
     case 56/*null.$8*/:
     case 57/*null.$9*/:
 
       return this.tokenizeNumber(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 175))
 
     case 36/*null.$DOLLAR*/:
     case 65/*null.$A*/:
     case 66/*null.$B*/:
     case 67/*null.$C*/:
     case 68/*null.$D*/:
     case 69/*null.$E*/:
     case 70/*null.$F*/:
     case 71/*null.$G*/:
     case 72/*null.$H*/:
@@ skipping 37 matching lines @@
     case 115/*null.$s*/:
     case 116/*null.$t*/:
     case 117/*null.$u*/:
     case 118/*null.$v*/:
     case 119/*null.$w*/:
     case 120/*null.$x*/:
     case 121/*null.$y*/:
     case 122/*null.$z*/:
 
       return this.tokenizeIdentifier(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 231))
 
     default:
 
-      if (next == -1) {
-        return -1;
+      if (next == -1.000000/*-1*/) {
+        return -1.000000/*-1*/;
       }
       if (next < 0x1f) {
         $throw(this.charOffset);
         $throw(new MalformedInputException(this.charOffset));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeTag = function(next) {
@@ skipping 32 matching lines @@
 ArrayBasedScanner$String.prototype.tokenizeCaret = function(next) {
   return this.select(61/*null.$EQ*/, "^=", "^");
 }
 ArrayBasedScanner$String.prototype.tokenizeBar = function(next) {
   next = this.advance();
   switch (next) {
     case 124/*null.$BAR*/:
 
       this.appendStringToken(124/*null.$BAR*/, "||");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 292))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(124/*null.$BAR*/, "|=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 295))
 
     default:
 
       this.appendStringToken(124/*null.$BAR*/, "|");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeAmpersand = function(next) {
   next = this.advance();
   switch (next) {
     case 38/*null.$AMPERSAND*/:
 
       this.appendStringToken(38/*null.$AMPERSAND*/, "&&");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 308))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(38/*null.$AMPERSAND*/, "&=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 311))
 
     default:
 
       this.appendStringToken(38/*null.$AMPERSAND*/, "&");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizePercent = function(next) {
   return this.select(61/*null.$EQ*/, "%=", "%");
 }
 ArrayBasedScanner$String.prototype.tokenizeMultiply = function(next) {
   return this.select(61/*null.$EQ*/, "*=", "*");
 }
 ArrayBasedScanner$String.prototype.tokenizeMinus = function(next) {
   next = this.advance();
   switch (next) {
     case 45/*null.$MINUS*/:
 
       this.appendStringToken(45/*null.$MINUS*/, "--");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 334))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(45/*null.$MINUS*/, "-=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 337))
 
     default:
 
       this.appendStringToken(45/*null.$MINUS*/, "-");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizePlus = function(next) {
   next = this.advance();
   switch (next) {
     case 43/*null.$PLUS*/:
 
       this.appendStringToken(43/*null.$PLUS*/, "++");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 350))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(43/*null.$PLUS*/, "+=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 353))
 
     default:
 
       this.appendStringToken(43/*null.$PLUS*/, "+");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeExclamation = function(next) {
   next = this.advance();
@@ skipping 11 matching lines @@
   this.appendStringToken(61/*null.$EQ*/, "=");
   return next;
 }
 ArrayBasedScanner$String.prototype.tokenizeGreaterThan = function(next) {
   next = this.advance();
   switch (next) {
     case 61/*null.$EQ*/:
 
       this.appendStringToken(62/*null.$GT*/, ">=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 386))
 
     case 62/*null.$GT*/:
 
       next = this.advance();
       switch (next) {
         case 61/*null.$EQ*/:
 
           this.appendStringToken(62/*null.$GT*/, ">>=");
           return this.advance();
+          $throw(new FallThroughError("./leg/scanner/scanner.dart", 392))
 
         case 62/*null.$GT*/:
 
           return this.select(61/*null.$EQ*/, ">>>=", ">>>");
+          $throw(new FallThroughError("./leg/scanner/scanner.dart", 394))
 
         default:
 
           this.appendStringToken(62/*null.$GT*/, ">>");
           return next;
 
       }
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 389))
 
     default:
 
       this.appendStringToken(62/*null.$GT*/, ">");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeLessThan = function(next) {
   next = this.advance();
   switch (next) {
     case 61/*null.$EQ*/:
 
       this.appendStringToken(60/*null.$LT*/, "<=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 411))
 
     case 60/*null.$LT*/:
 
       return this.select(61/*null.$EQ*/, "<<=", "<<");
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 413))
 
     default:
 
       this.appendStringToken(60/*null.$LT*/, "<");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeNumber = function(next) {
   var start = this.byteOffset;
   while (true) {
     next = this.advance();
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 435))
 
       case 46/*null.$PERIOD*/:
 
         return this.tokenizeFractionPart(this.advance(), start);
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 438))
 
       case 101/*null.$e*/:
       case 69/*null.$E*/:
       case 100/*null.$d*/:
       case 68/*null.$D*/:
 
         return this.tokenizeFractionPart(next, start);
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 444))
 
       default:
 
         this.appendByteStringToken(105/*null.$i*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeHexOrNumber = function(next) {
@@ skipping 28 matching lines @@
       case 70/*null.$F*/:
       case 97/*null.$a*/:
       case 98/*null.$b*/:
       case 99/*null.$c*/:
       case 100/*null.$d*/:
       case 101/*null.$e*/:
       case 102/*null.$f*/:
 
         hasDigits = true;
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 491))
 
       default:
 
         if (!hasDigits) {
           $throw(new MalformedInputException(this.charOffset));
         }
         this.appendByteStringToken(120/*null.$x*/, this.asciiString(start));
         return next;
 
     }
@@ skipping 10 matching lines @@
     case 52/*null.$4*/:
     case 53/*null.$5*/:
     case 54/*null.$6*/:
     case 55/*null.$7*/:
     case 56/*null.$8*/:
     case 57/*null.$9*/:
 
       {
         return this.tokenizeFractionPart(next, start);
       }
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 516))
 
     case 46/*null.$PERIOD*/:
 
       return this.select(46/*null.$PERIOD*/, "...", "..");
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 521))
 
     default:
 
       this.appendStringToken(46/*null.$PERIOD*/, ".");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
   while (!done) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 543))
 
       case 101/*null.$e*/:
       case 69/*null.$E*/:
 
         next = this.tokenizeExponent(this.advance());
         done = true;
         continue LOOP;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 549))
 
       default:
 
         done = true;
         continue LOOP;
 
     }
     next = this.advance();
   }
   if (next == 100/*null.$d*/ || next == 68/*null.$D*/) {
@@ skipping 15 matching lines @@
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         hasDigits = true;
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 582))
 
       default:
 
         if (!hasDigits) {
           $throw(new MalformedInputException(this.charOffset));
         }
         return next;
 
     }
     next = this.advance();
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
   switch (next) {
     case 42/*null.$STAR*/:
 
       return this.tokenizeMultiLineComment(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 598))
 
     case 47/*null.$SLASH*/:
 
       return this.tokenizeSingleLineComment(next);
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 601))
 
     case 61/*null.$EQ*/:
 
       this.appendStringToken(47/*null.$SLASH*/, "/=");
       return this.advance();
+      $throw(new FallThroughError("./leg/scanner/scanner.dart", 605))
 
     default:
 
       this.appendStringToken(47/*null.$SLASH*/, "/");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeSingleLineComment = function(next) {
   while (true) {
     next = this.advance();
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
       case 10/*null.$LF*/:
       case 13/*null.$CR*/:
 
         return next;
 
     }
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
   while (true) {
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
 
         return next;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 630))
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
         if (next == 47/*null.$SLASH*/) {
           return this.advance();
         }
-        else if (next == -1) {
+        else if (next == -1.000000/*-1*/) {
           return next;
         }
         break;
+        $throw(new FallThroughError("./leg/scanner/scanner.dart", 638))
 
       default:
 
         next = this.advance();
         break;
 
     }
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeIdentifier = function(next) {
@@ skipping 14 matching lines @@
       state = null;
     }
     else if (next < 128) {
       if (state != null && state.isLeaf()) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if (isAscii) {
         this.appendByteStringToken(97/*null.$a*/, this.asciiString(start));
       }
       else {
-        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1));
+        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1.000000/*-1*/));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.byteOffset;
       do {
         next = this.nextByte();
       }
       while (next > 127)
-      var string = this.utf8String(nonAsciiStart, -1).toString();
+      var string = this.utf8String(nonAsciiStart, -1.000000/*-1*/).toString();
       isAscii = false;
       this.addToCharOffset(string.length);
       return next;
     }
     next = this.advance();
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeRawString = function(next) {
   var start = this.byteOffset;
   next = this.advance();
   if (next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/) {
     return this.tokenizeString(next, start, true);
   }
   else {
     $throw(new MalformedInputException(this.charOffset));
   }
 }
 ArrayBasedScanner$String.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(q, this.utf8String(start, -1));
+      this.appendByteStringToken(q, this.utf8String(start, -1.000000/*-1*/));
       return next;
     }
   }
   if (raw) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next == 92/*null.$BACKSLASH*/) {
       next = this.advance();
-      if (next == -1) {
+      if (next == -1.000000/*-1*/) {
         $throw(new MalformedInputException(this.charOffset));
       }
     }
     else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.charOffset));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.charOffset));
 }
 ArrayBasedScanner$String.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.charOffset));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.charOffset));
 }
 ArrayBasedScanner$String.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q) {
       next = this.advance();
       if (next == q) {
         next = this.advance();
         if (next == q) {
           this.appendByteStringToken(q, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
@@ skipping 47 matching lines @@
 TokenString.prototype.get$text = function() { return this.text; };
 TokenString.prototype.$eq = function(other) {
   return (other instanceof TokenString) && this.text == other.get$text();
 }
 TokenString.prototype.hashCode = function() {
   return this.text.hashCode();
 }
 TokenString.prototype.toString = function() {
   return this.text;
 }
-// ********** Code for Node **************
-function Node() {}
-Node.prototype.hashCode = function() {
+// ********** Code for tree_Node **************
+function tree_Node() {}
+tree_Node.prototype.hashCode = function() {
   return this._hashCode;
 }
-Node.prototype.toString = function() {
+tree_Node.prototype.toString = function() {
   return this.get$debugString();
 }
-// ********** Code for Expression **************
-function Expression() {}
-$inherits(Expression, Node);
-// ********** Code for Statement **************
-function Statement() {}
-$inherits(Statement, Node);
+// ********** Code for tree_Expression **************
+function tree_Expression() {}
+$inherits(tree_Expression, tree_Node);
+// ********** Code for tree_Statement **************
+function tree_Statement() {}
+$inherits(tree_Statement, tree_Node);
 // ********** Code for Invocation **************
 function Invocation(receiver, selector, argumentsNode) {
   this.debugString = "invocation"
   this.receiver = receiver;
   this.selector = selector;
   this.argumentsNode = argumentsNode;
   // Initializers done
 }
-$inherits(Invocation, Expression);
+$inherits(Invocation, tree_Expression);
 Invocation.prototype.get$arguments = function() {
   return this.argumentsNode.nodes;
 }
 Invocation.prototype.get$debugString = function() { return this.debugString; };
 Invocation.prototype.accept = function(visitor) {
   return visitor.visitInvocation(this);
 }
-// ********** Code for NewExpression **************
-function NewExpression() {}
-$inherits(NewExpression, Expression);
-NewExpression.prototype.get$debugString = function() { return this.debugString; };
+// ********** Code for tree_NewExpression **************
+function tree_NewExpression() {}
+$inherits(tree_NewExpression, tree_Expression);
+tree_NewExpression.prototype.get$debugString = function() { return this.debugString; };
 // ********** Code for NodeList **************
 function NodeList(beginToken, nodes, endToken, delimiter) {
   this.debugString = "node list"
   this.beginToken = beginToken;
   this.nodes = nodes;
   this.endToken = endToken;
   this.delimiter = delimiter;
   // Initializers done
 }
-$inherits(NodeList, Node);
+$inherits(NodeList, tree_Node);
 NodeList.prototype.get$debugString = function() { return this.debugString; };
 NodeList.prototype.accept = function(visitor) {
   return visitor.visitNodeList(this);
 }
 // ********** Code for Block **************
 function Block(beginToken, statements, endToken) {
   this.debugString = "block"
   this.beginToken = beginToken;
   this.statements = statements;
   this.endToken = endToken;
   // Initializers done
 }
-$inherits(Block, Statement);
+$inherits(Block, tree_Statement);
 Block.prototype.get$debugString = function() { return this.debugString; };
 Block.prototype.accept = function(visitor) {
   return visitor.visitBlock(this);
 }
 // ********** Code for FunctionExpression **************
 function FunctionExpression(name, parameters, body, returnType) {
   this.debugString = "function expression"
   this.name = name;
   this.parameters = parameters;
   this.body = body;
   this.returnType = returnType;
   // Initializers done
 }
-$inherits(FunctionExpression, Expression);
+$inherits(FunctionExpression, tree_Expression);
 FunctionExpression.prototype.get$name = function() { return this.name; };
 FunctionExpression.prototype.get$parameters = function() { return this.parameters; };
 FunctionExpression.prototype.get$returnType = function() { return this.returnType; };
 FunctionExpression.prototype.get$debugString = function() { return this.debugString; };
 FunctionExpression.prototype.accept = function(visitor) {
   return visitor.visitFunctionExpression(this);
 }
 // ********** Code for Literal **************
 function Literal(value) {
   this.value = value;
   // Initializers done
 }
-$inherits(Literal, Expression);
+$inherits(Literal, tree_Expression);
 Literal.prototype.get$value = function() { return this.value; };
 Literal.prototype.get$debugString = function() {
   return ("" + this.value + "");
 }
 Literal.prototype.accept = function(visitor) {
   return visitor.visitLiteral(this);
 }
-// ********** Code for Identifier **************
-function Identifier(string) {
+// ********** Code for tree_Identifier **************
+function tree_Identifier(string) {
   this.string = string;
   // Initializers done
 }
-$inherits(Identifier, Expression);
-Identifier.prototype.get$debugString = function() {
+$inherits(tree_Identifier, tree_Expression);
+tree_Identifier.prototype.get$debugString = function() {
   return ("" + this.string + "");
 }
-Identifier.prototype.accept = function(visitor) {
+tree_Identifier.prototype.accept = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 // ********** Code for Operator **************
 function Operator(string) {
   this.string = string;
   // Initializers done
 }
-$inherits(Operator, Node);
+$inherits(Operator, tree_Node);
 Operator.prototype.get$debugString = function() {
   return ("" + this.string + "");
 }
 Operator.prototype.accept = function(visitor) {
   return visitor.visitOperator(this);
 }
 // ********** Code for Return **************
 function Return(expression) {
   this.debugString = "return"
   this.expression = expression;
   // Initializers done
 }
-$inherits(Return, Statement);
+$inherits(Return, tree_Statement);
 Return.prototype.get$debugString = function() { return this.debugString; };
 Return.prototype.accept = function(visitor) {
   return visitor.visitReturn(this);
 }
-// ********** Code for ExpressionStatement **************
-function ExpressionStatement(expression) {
+// ********** Code for tree_ExpressionStatement **************
+function tree_ExpressionStatement(expression) {
   this.expression = expression;
   // Initializers done
 }
-$inherits(ExpressionStatement, Statement);
-ExpressionStatement.prototype.get$debugString = function() {
+$inherits(tree_ExpressionStatement, tree_Statement);
+tree_ExpressionStatement.prototype.get$debugString = function() {
   return ("" + this.expression.get$debugString() + "");
 }
-ExpressionStatement.prototype.accept = function(visitor) {
+tree_ExpressionStatement.prototype.accept = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
 // ********** Code for TypeAnnotation **************
 function TypeAnnotation(typeName) {
   this.typeName = typeName;
   // Initializers done
 }
-$inherits(TypeAnnotation, Node);
+$inherits(TypeAnnotation, tree_Node);
 TypeAnnotation.prototype.get$debugString = function() {
   return ("" + this.typeName + "");
 }
 TypeAnnotation.prototype.accept = function(visitor) {
   return visitor.visitTypeAnnotation(this);
 }
 // ********** Code for top level **************
 //  ********** Library emitter **************
 // ********** Code for EmitterStage **************
 function EmitterStage(pipeline) {
@@ skipping 644 matching lines @@
   var text = elements.get$head().toString();
   var text2 = elements.get$tail().isEmpty() ? '' : elements.get$tail().get$head().toString();
   this.pipeline.log(text);
   this.pipeline.log(text2);
   var emptyList = new NodeList(null, LinkFactory.Link$fromList$factory([]));
   if (text == 'main ( ) { print ( 3 + 4 ) ; }') {
     var three = new Literal(3);
     var four = new Literal(4);
     var plus = ParserStage.newOperator('+');
     var sum = new Invocation(three, plus, ParserStage.newArguments([four]));
-    var print = new ExpressionStatement(new Invocation(null, ParserStage.newIdentifier('print'), ParserStage.newArguments([sum])));
+    var print = new tree_ExpressionStatement(new Invocation(null, ParserStage.newIdentifier('print'), ParserStage.newArguments([sum])));
     var body = new Block(null, LinkFactory.Link$factory(print), null);
     var node = new FunctionExpression(ParserStage.newIdentifier('main'), emptyList, body);
     this.pipeline.universe.define(new Element(new TokenString('main'), node));
   }
   else if ((text == 'foo ( ) { return 3 + 4 ; }') && text2 == 'main ( ) { print ( foo ( ) ) ; }') {
     var foo = new Invocation(null, ParserStage.newIdentifier('foo'), ParserStage.newArguments([]));
-    var print = new ExpressionStatement(new Invocation(null, ParserStage.newIdentifier('print'), ParserStage.newArguments([foo])));
+    var print = new tree_ExpressionStatement(new Invocation(null, ParserStage.newIdentifier('print'), ParserStage.newArguments([foo])));
     var body = new Block(null, LinkFactory.Link$factory(print), null);
     var node = new FunctionExpression(ParserStage.newIdentifier('main'), emptyList, body);
     this.pipeline.universe.define(new Element(new TokenString('main'), node));
     var three = new Literal(3);
     var four = new Literal(4);
     var plus = ParserStage.newOperator('+');
     var sum = new Invocation(three, plus, ParserStage.newArguments([four]));
     var ret = new Return(sum);
     body = new Block(null, LinkFactory.Link$factory(ret), null);
     node = new FunctionExpression(ParserStage.newIdentifier('foo'), emptyList, body);
     this.pipeline.universe.define(new Element(new TokenString('foo'), node));
   }
   else if (text == 'void main ( ) { return 3 ; }') {
     var three = new Literal(3);
     var body = new Block(null, LinkFactory.Link$factory(new Return(three)), null);
     var node = new FunctionExpression(ParserStage.newIdentifier('main'), emptyList, body, new TypeAnnotation('void'));
     this.pipeline.universe.define(new Element(new TokenString('main'), node));
   }
   else {
     this.pipeline.cancel();
   }
   return input;
 }
 ParserStage.prototype.tokenize = function(text) {
   var tokens = this.pipeline.world.withTiming('[leg] scanning', (function () {
     return new StringScanner(text).tokenize();
   })
   );
   var listener = new Listener();
-  var parser = new Parser(listener);
+  var parser = new scanner_Parser(listener);
   this.pipeline.world.withTiming('[leg] parsing', (function () {
     return parser.parseUnit(tokens);
   })
   );
   this.pipeline.log(new TokenPrinter(tokens));
   this.pipeline.log(("Parsing " + listener.libraryTagCount + " tags, ") + ("" + listener.classCount + " classes, ") + ("" + listener.interfaceCount + " interfaces, ") + ("" + listener.aliasCount + " typedefs, ") + ("" + listener.topLevelMemberCount + " top-level members"));
   return listener.topLevelElements;
 }
 ParserStage.newArguments = function(expressions) {
   return new NodeList(null, LinkFactory.Link$fromList$factory(expressions), null, null);
 }
 ParserStage.newIdentifier = function(text) {
-  return new Identifier(new TokenString(text));
+  return new tree_Identifier(new TokenString(text));
 }
 ParserStage.newOperator = function(text) {
   return new Operator(new TokenString(text));
 }
 // ********** Code for Universe **************
 function Universe() {
   this.world = $map([]);
   this.generatedCode = $map([]);
   // Initializers done
 }
@@ skipping 237 matching lines @@
   return this.name.text;
 }
 // ********** Code for FunctionType **************
 function FunctionType(returnType) {
   this.returnType = returnType;
   // Initializers done
 }
 FunctionType.prototype.get$returnType = function() { return this.returnType; };
 // ********** Code for Types **************
 function Types() {
-  this.VOID = const$133/*const SimpleType(const TokenString('void'))*/
-  this.INT = const$135/*const SimpleType(const TokenString('int'))*/
-  this.DYNAMIC = const$137/*const SimpleType(const TokenString('Dynamic'))*/
+  this.VOID = const$321/*const SimpleType(const TokenString('void'))*/
+  this.INT = const$323/*const SimpleType(const TokenString('int'))*/
+  this.DYNAMIC = const$325/*const SimpleType(const TokenString('Dynamic'))*/
   // 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(pipeline, elements, types, listener) {
@@ skipping 60 matching lines @@
   }
   return this.types.VOID;
 }
 // ********** Code for leg_Script **************
 function leg_Script(text) {
   this.text = text;
   // Initializers done
 }
 leg_Script.prototype.get$text = function() { return this.text; };
 // ********** Code for top level **************
-function compile(world) {
+function leg_compile(world) {
   var file = world.readFile(options.dartScript);
   var script = new leg_Script(file.get$text());
   var pipeline = new WorldPipeline(world, script);
   return pipeline.run();
 }
 //  ********** Library io **************
 // ********** Code for top level **************
 function writeString(outfile, text) {
   get$fs().writeFileSync(outfile, text);
 }
@@ skipping 23 matching lines @@
   }
 }
 CodeWriter.prototype.comment = function(text) {
   if (this.writeComments) {
     this.writeln(text);
   }
 }
 CodeWriter.prototype.write = function(text) {
   if (text.length == 0) return;
   if (this._pendingIndent) this._indent();
-  if (text.indexOf('\n', 0) != -1) {
+  if (text.indexOf('\n', 0) != -1.000000/*-1*/) {
     var lines = text.split('\n');
     for (var i = 0;
      i < lines.length - 1; i++) {
       this.writeln(lines.$index(i));
     }
     this.write(lines.$index(lines.length - 1));
   }
   else {
     this._buf.add(text);
   }
@@ skipping 42 matching lines @@
       pieces.removeLast();
     }
     else if ($ne(piece, '')) {
       pieces.add(piece);
     }
   }
   return Strings.join(pieces, '/');
 }
 FileSystem.prototype.dirname = function(path) {
   var lastSlash = path.lastIndexOf('/', path.length);
-  if (lastSlash == -1) {
+  if (lastSlash == -1.000000/*-1*/) {
     return '.';
   }
   else {
     return path.substring(0, lastSlash);
   }
 }
 FileSystem.prototype.basename = function(path) {
   var lastSlash = path.lastIndexOf('/', path.length);
-  if (lastSlash == -1) {
+  if (lastSlash == -1.000000/*-1*/) {
     return path;
   }
   else {
     return path.substring(lastSlash + 1);
   }
 }
 FileSystem.prototype.readFile = function(fullname) {
   var filename = this.specialLibs.$index(fullname);
   if (filename == null) {
     filename = fullname;
@@ skipping 261 matching lines @@
   var values = map.getValues();
   values.sort(this.get$_compareMembers());
   return values;
 }
 WorldGenerator.prototype._compareMembers = function(x, y) {
   if (x.get$span() != null && y.get$span() != null) {
     var spans = x.get$span().compareTo(y.get$span());
     if (spans != 0) return spans;
   }
   if (x.get$span() == null) return 1;
-  if (y.get$span() == null) return -1;
+  if (y.get$span() == null) return -1.000000/*-1*/;
   return x.get$name().compareTo(y.get$name());
 }
 WorldGenerator.prototype.get$_compareMembers = function() {
   return WorldGenerator.prototype._compareMembers.bind(this);
 }
 WorldGenerator.prototype.writeVarCallStubs = function() {
   if (this._varCallStubs.get$length() > 0) {
     this.writer.comment('//  ********** Call Stubs **************');
     var $list = MapUtils.valuesSortedByKeys(this._varCallStubs);
     for (var $i = 0;$i < $list.length; $i++) {
@@ skipping 514 matching lines @@
 }
 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) {
-  var parser = new lang_Parser(node.span.file, false, node.span.start);
+  var parser = new Parser(node.span.file, false, node.span.start);
   this.visitStatementsInBlock(parser.block());
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var isFinal = false;
   if (node.modifiers != null && node.modifiers.$index(0).kind == 96/*TokenKind.FINAL*/) {
     isFinal = true;
   }
   this.writer.write('var ');
   var type = this.method.resolveType(node.type);
   for (var i = 0;
@@ skipping 249 matching lines @@
   for (var $i = 0;$i < $list.length; $i++) {
     var case_ = $list.$index($i);
     if (case_.label != null) {
       world.error('unimplemented: labeled case statement', case_.get$span());
     }
     this._pushBlock(false);
     for (var i = 0;
      i < case_.cases.length; i++) {
       var expr = case_.cases.$index(i);
       if (expr == null) {
+        if (i < case_.cases.length - 1) {
+          world.error('default clause must be the last case', case_.get$span());
+        }
         this.writer.writeln('default:');
       }
       else {
         var value = this.visitValue(expr);
         this.writer.writeln(('case ' + value.code + ':'));
       }
     }
     this.writer.enterBlock('');
     var $list0 = case_.statements;
     for (var $i0 = case_.statements.iterator(); $i0.hasNext(); ) {
       var stmt = $i0.next();
       stmt.visit(this);
     }
+    if ($ne(case_, node.cases.$index(node.cases.length - 1))) {
+      var span = case_.statements.$index(case_.statements.length - 1).get$span();
+      this.writer.writeln(('\$throw(new FallThroughError("' + span.file.filename + '",') + (' ' + span.file.getLine(span.start) + '))'));
+    }
     this.writer.exitBlock('');
     this._popBlock();
   }
   this.writer.exitBlock('}');
 }
 MethodGenerator.prototype.visitBlockStatement = function(node) {
   this._pushBlock(false);
   this.writer.enterBlock('{');
   var $list = node.body;
   for (var $i = 0;$i < $list.length; $i++) {
@@ skipping 155 matching lines @@
     }
     if (x.code == 'null' || y.code == 'null') {
       var op = node.op.toString().substring(0, 2);
       return new Value(null, ('' + x.code + ' ' + op + ' ' + y.code + ''), false, true, false);
     }
     else {
       return new Value(null, ('' + x.code + ' ' + node.op + ' ' + y.code + ''), false, true, false);
     }
   }
   var assignKind = TokenKind.kindFromAssign(node.op.kind);
-  if (assignKind == -1) {
+  if (assignKind == -1.000000/*-1*/) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     var name = TokenKind.binaryMethodName(node.op.kind);
     if (node.op.kind == 49/*TokenKind.NE*/) {
       name = '\$ne';
     }
     if (name == null) {
       world.internalError(('unimplemented binary op ' + node.op + ''), node.span);
       return;
     }
@@ skipping 105 matching lines @@
     case 17/*TokenKind.DECR*/:
 
       if (value.type.get$isNum()) {
         return new Value(value.type, ('' + node.op + '' + value.code + ''), false, true, false);
       }
       else {
         var kind = (16/*TokenKind.INCR*/ == node.op.kind ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/);
         var operand = new LiteralExpression(1, new TypeReference(node.span, world.numType), '1', node.span);
         return this._visitAssign(kind, node.self, operand, node, to$call$1(null));
       }
+      $throw(new FallThroughError("./gen.dart", 1743))
 
     case 19/*TokenKind.NOT*/:
 
       if (value.type.get$isBool() && value.get$isConst()) {
         var newVal = !value.get$actualValue();
         return EvaluatedValue.EvaluatedValue$factory(value.type, newVal, ('' + newVal + ''), node.span);
       }
       else {
         return new Value(world.boolType, ('!' + value.code + ''), false, true, false);
       }
+      $throw(new FallThroughError("./gen.dart", 1758))
 
     case 42/*TokenKind.ADD*/:
     case 43/*TokenKind.SUB*/:
     case 18/*TokenKind.BIT_NOT*/:
 
       if (value.type.get$isNum()) {
         if (value.get$isConst()) {
           if (node.op.kind == 42/*TokenKind.ADD*/) {
             return value;
           }
           else if (node.op.kind == 43/*TokenKind.SUB*/) {
             var newVal = $negate(value.get$actualValue());
             return EvaluatedValue.EvaluatedValue$factory(value.type, newVal, ('' + newVal + ''), node.span);
           }
           else {
             var newVal = (~value.get$actualValue().toInt()).toDouble();
             return EvaluatedValue.EvaluatedValue$factory(value.type, newVal, ('' + newVal + ''), node.span);
           }
         }
         return new Value(value.type, ('' + node.op + '' + value.code + ''), false, true, false);
       }
       else {
         var name;
         if (node.op.kind == 18/*TokenKind.BIT_NOT*/) name = '\$bit_not';
         else if (node.op.kind == 43/*TokenKind.SUB*/) name = '\$negate';
         else world.internalError(('unimplemented: unary ' + node.op + ' on var'), node.span);
         return new Value(world.varType, ('' + name + '(' + value.code + ')'), false, true, false);
       }
+      $throw(new FallThroughError("./gen.dart", 1769))
 
     default:
 
       world.internalError(('unimplemented: ' + node.op + ''), node.span);
 
   }
 }
 MethodGenerator.prototype.visitPostfixExpression = function(node, isVoid) {
   var $this = this; // closure support
   var value = this.visitValue(node.body);
@@ skipping 126 matching lines @@
     var value = EvaluatedValue.EvaluatedValue$factory(factType, code, code, node.span);
     return this.parent.globalForConst(value, argValues);
   }
   return new Value(factType, code, false, true, false);
 }
 MethodGenerator.prototype.visitConditionalExpression = function(node) {
   var test = this.visitBool(node.test);
   var trueBranch = this.visitValue(node.trueBranch);
   var falseBranch = this.visitValue(node.falseBranch);
   var code = ('' + test.code + ' ? ' + trueBranch.code + ' : ' + falseBranch.code + '');
-  return new Value(lang_Type.union(trueBranch.type, falseBranch.type), code, false, true, false);
+  return new Value(Type.union(trueBranch.type, falseBranch.type), code, false, true, false);
 }
 MethodGenerator.prototype.visitIsExpression = function(node) {
   var value = this.visitValue(node.x);
   var type = this.method.resolveType(node.type);
   return this._isTest(value, type, node.span, node.isTrue, false);
 }
 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);
@@ skipping 106 matching lines @@
 Arguments.prototype.getName = function(i) {
   return this.nodes.$index(i).label.name;
 }
 Arguments.prototype.getIndexOfName = function(name) {
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     if (this.getName(i) == name) {
       return i;
     }
   }
-  return -1;
+  return -1.000000/*-1*/;
 }
 Arguments.prototype.getValue = function(name) {
   var i = this.getIndexOfName(name);
   return i >= 0 ? this.values.$index(i) : null;
 }
 Arguments.prototype.get$bareCount = function() {
   if (this._bareCount == null) {
     this._bareCount = this.get$length();
     if (this.nodes != null) {
       for (var i = 0;
@@ skipping 216 matching lines @@
   this.sources = [];
   this.addSource(this.library.baseSource);
 }
 LibraryVisitor.prototype.get$library = function() { return this.library; };
 LibraryVisitor.prototype.addSourceFromName = function(name) {
   var source = world.readFile(this.library.makeFullPath(name));
   this.sources.add(source);
 }
 LibraryVisitor.prototype.addSource = function(source) {
   this.library.sources.add(source);
-  var parser = new lang_Parser(source, options.dietParse, 0);
+  var parser = new Parser(source, options.dietParse, 0);
   var unit = parser.compilationUnit();
   for (var $i = 0;$i < unit.length; $i++) {
     var def = unit.$index($i);
     def.visit(this);
   }
   var newSources = this.sources;
   this.sources = [];
   for (var $i = newSources.iterator(); $i.hasNext(); ) {
     var source0 = $i.next();
     this.addSource(source0);
   }
 }
 LibraryVisitor.prototype.visitDirectiveDefinition = function(node) {
   var name;
   switch (node.name.name) {
     case "library":
 
       name = this.getSingleStringArg(node);
       if (this.library.name == null) {
         this.library.name = name;
         if ($eq(name, 'node') || $eq(name, 'dom')) {
           this.library.topType.isNativeType = true;
         }
       }
       else {
         world.error('already specified library name', node.span);
       }
       break;
+      $throw(new FallThroughError("./library.dart", 271))
 
     case "import":
 
       name = this.getFirstStringArg(node);
       var prefix = this.tryGetNamedStringArg(node, 'prefix');
       if (node.arguments.length > 2 || node.arguments.length == 2 && prefix == null) {
         world.error('expected at most one "name" argument and one optional "prefix"' + (' but found ' + node.arguments.length + ''), node.span);
       }
       else if ($ne(prefix, null) && prefix.indexOf('.', 0) >= 0) {
         world.error('library prefix canot contain "."', node.span);
       }
       if ($eq(prefix, '')) prefix = null;
       this.library.addImport(this.library.makeFullPath(name), prefix);
       break;
+      $throw(new FallThroughError("./library.dart", 289))
 
     case "source":
 
       name = this.getSingleStringArg(node);
       this.addSourceFromName(name);
       break;
+      $throw(new FallThroughError("./library.dart", 294))
 
     case "native":
 
       name = this.getSingleStringArg(node);
       this.library.addNative(this.library.makeFullPath(name));
       break;
+      $throw(new FallThroughError("./library.dart", 299))
 
     default:
 
       world.error(('unknown directive: ' + node.name.name + ''), node.span);
 
   }
 }
 LibraryVisitor.prototype.getSingleStringArg = function(node) {
   if (node.arguments.length != 1) {
     world.error(('expected exactly one argument but found ' + node.arguments.length + ''), node.span);
@@ skipping 749 matching lines @@
       ival0 = val0.toInt();
       if (args.values.length > 0) {
         val1 = args.values.$index(0).get$dynamic().get$actualValue();
         ival1 = val1.toInt();
       }
       switch (this.name) {
         case '\$negate':
 
           value = -val0;
           break;
+          $throw(new FallThroughError("./member.dart", 763))
 
         case '\$add':
 
           value = val0 + val1;
           break;
+          $throw(new FallThroughError("./member.dart", 764))
 
         case '\$sub':
 
           value = val0 - val1;
           break;
+          $throw(new FallThroughError("./member.dart", 765))
 
         case '\$mul':
 
           value = val0 * val1;
           break;
+          $throw(new FallThroughError("./member.dart", 766))
 
         case '\$div':
 
           value = val0 / val1;
           break;
+          $throw(new FallThroughError("./member.dart", 767))
 
         case '\$truncdiv':
 
           value = $truncdiv(val0, val1);
           break;
+          $throw(new FallThroughError("./member.dart", 768))
 
         case '\$mod':
 
           value = val0 % val1;
           break;
+          $throw(new FallThroughError("./member.dart", 769))
 
         case '\$eq':
 
           value = val0 == val1;
           break;
+          $throw(new FallThroughError("./member.dart", 770))
 
         case '\$lt':
 
           value = val0 < val1;
           break;
+          $throw(new FallThroughError("./member.dart", 771))
 
         case '\$gt':
 
           value = val0 > val1;
           break;
+          $throw(new FallThroughError("./member.dart", 772))
 
         case '\$lte':
 
           value = val0 <= val1;
           break;
+          $throw(new FallThroughError("./member.dart", 773))
 
         case '\$gte':
 
           value = val0 >= val1;
           break;
+          $throw(new FallThroughError("./member.dart", 774))
 
         case '\$ne':
 
           value = val0 != val1;
           break;
+          $throw(new FallThroughError("./member.dart", 775))
 
         case '\$bit_not':
 
           value = (~ival0).toDouble();
           break;
+          $throw(new FallThroughError("./member.dart", 778))
 
         case '\$bit_or':
 
           value = (ival0 | ival1).toDouble();
           break;
+          $throw(new FallThroughError("./member.dart", 779))
 
         case '\$bit_xor':
 
           value = (ival0 ^ ival1).toDouble();
           break;
+          $throw(new FallThroughError("./member.dart", 780))
 
         case '\$bit_and':
 
           value = (ival0 & ival1).toDouble();
           break;
+          $throw(new FallThroughError("./member.dart", 781))
 
         case '\$shl':
 
           value = (ival0 << ival1).toDouble();
           break;
+          $throw(new FallThroughError("./member.dart", 782))
 
         case '\$sar':
 
           value = (ival0 >> ival1).toDouble();
           break;
+          $throw(new FallThroughError("./member.dart", 783))
 
         case '\$shr':
 
           value = (ival0 >>> ival1).toDouble();
           break;
 
       }
       return EvaluatedValue.EvaluatedValue$factory(this.returnType, value, ("" + value + ""), node.span);
     }
   }
@@ skipping 452 matching lines @@
 }
 MemberSet.prototype._union = function(x, y, node) {
   var result = this._tryUnion(x, y, node);
   if (result.code == null) {
     world.fatal(('mismatched code for ' + this.name + ' (' + x.code + ', ' + y.code + ')'), node.span);
   }
   return result;
 }
 MemberSet.prototype._tryUnion = function(x, y, node) {
   if (x == null) return y;
-  var type = lang_Type.union(x.type, y.type);
+  var type = Type.union(x.type, y.type);
   if (x.code == y.code) {
     if ($eq(type, x.type)) {
       return x;
     }
     else if (x.get$isConst() || y.get$isConst()) {
       world.internalError("unexpected: union of const values ");
     }
     else {
       return new Value(type, x.code, x.isSuper && y.isSuper, x.needsTemp || y.needsTemp, x.isType && y.isType);
     }
@@ skipping 24 matching lines @@
 FactoryMap.prototype.forEach = function(f) {
   this.factories.forEach((function (_, constructors) {
     constructors.forEach((function (_0, member) {
       f(member);
     })
     );
   })
   );
 }
 FactoryMap.prototype.forEach$1 = FactoryMap.prototype.forEach;
-// ********** Code for lang_Token **************
-function lang_Token(kind, source, start, end) {
+// ********** Code for Token **************
+function Token(kind, source, start, end) {
   this.kind = kind;
   this.source = source;
   this.start = start;
   this.end = end;
   // Initializers done
 }
-lang_Token.prototype.get$text = function() {
+Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
 }
-lang_Token.prototype.toString = function() {
+Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
   if ($ne(kindText, actualText)) {
     if (actualText.length > 10) {
       actualText = actualText.substring(0, 8) + '...';
     }
     return ('' + kindText + '(' + actualText + ')');
   }
   else {
     return kindText;
   }
 }
-lang_Token.prototype.get$span = function() {
+Token.prototype.get$span = function() {
   return new SourceSpan(this.source, this.start, this.end);
 }
 // ********** Code for SourceFile **************
 function SourceFile(filename, _text) {
   this.filename = filename;
   this._text = _text;
   // Initializers done
 }
 SourceFile.prototype.get$text = function() {
   return this._text;
@@ skipping 74 matching lines @@
     var d = this.start - other.start;
     return d == 0 ? (this.end - other.end) : d;
   }
   return this.file.compareTo(other.file);
 }
 // ********** Code for InterpStack **************
 function InterpStack(previous, quote, isMultiline) {
   this.previous = previous;
   this.quote = quote;
   this.isMultiline = isMultiline;
-  this.depth = -1;
+  this.depth = -1.000000/*-1*/;
   // Initializers done
 }
 InterpStack.prototype.pop = function() {
   return this.previous;
 }
 InterpStack.push = function(stack, quote, isMultiline) {
   var newStack = new InterpStack(stack, quote, isMultiline);
   if (stack != null) newStack.previous = stack;
   return newStack;
 }
 // ********** Code for TokenizerBase **************
 function TokenizerBase(_source, _skipWhitespace, _index) {
   this._source = _source;
   this._skipWhitespace = _skipWhitespace;
-  this._index = _index;
+  this._lang_index = _index;
   // Initializers done
   this._text = this._source.get$text();
 }
 $inherits(TokenizerBase, TokenizerHelpers);
 TokenizerBase.prototype._nextChar = function() {
-  if (this._index < this._text.length) {
-    return this._text.charCodeAt(this._index++);
+  if (this._lang_index < this._text.length) {
+    return this._text.charCodeAt(this._lang_index++);
   }
   else {
     return 0;
   }
 }
 TokenizerBase.prototype._peekChar = function() {
-  if (this._index < this._text.length) {
-    return this._text.charCodeAt(this._index);
+  if (this._lang_index < this._text.length) {
+    return this._text.charCodeAt(this._lang_index);
   }
   else {
     return 0;
   }
 }
 TokenizerBase.prototype._maybeEatChar = function(ch) {
-  if (this._index < this._text.length) {
-    if (this._text.charCodeAt(this._index) == ch) {
-      this._index++;
+  if (this._lang_index < this._text.length) {
+    if (this._text.charCodeAt(this._lang_index) == ch) {
+      this._lang_index++;
       return true;
     }
     else {
       return false;
     }
   }
   else {
     return false;
   }
 }
 TokenizerBase.prototype._finishToken = function(kind) {
-  return new lang_Token(kind, this._source, this._startIndex, this._index);
+  return new Token(kind, this._source, this._startIndex, this._lang_index);
 }
 TokenizerBase.prototype._errorToken = function() {
   return this._finishToken(64/*TokenKind.ERROR*/);
 }
 TokenizerBase.prototype.finishWhitespace = function() {
-  while (this._index < this._text.length) {
-    if (!TokenizerHelpers.isWhitespace(this._text.charCodeAt(this._index++))) {
-      this._index--;
+  while (this._lang_index < this._text.length) {
+    if (!TokenizerHelpers.isWhitespace(this._text.charCodeAt(this._lang_index++))) {
+      this._lang_index--;
       return this.next();
     }
   }
   return this._finishToken(1/*TokenKind.END_OF_FILE*/);
 }
 TokenizerBase.prototype.finishHashBang = function() {
   while (true) {
     var ch = this._nextChar();
     if (ch == 0 || ch == 10 || ch == 13) {
       return this._finishToken(13/*TokenKind.HASHBANG*/);
@@ skipping 26 matching lines @@
         }
         else {
           return this._finishToken(63/*TokenKind.COMMENT*/);
         }
       }
     }
   }
   return this._errorToken();
 }
 TokenizerBase.prototype.eatDigits = function() {
-  while (this._index < this._text.length) {
-    if (TokenizerHelpers.isDigit(this._text.charCodeAt(this._index))) {
-      this._index++;
+  while (this._lang_index < this._text.length) {
+    if (TokenizerHelpers.isDigit(this._text.charCodeAt(this._lang_index))) {
+      this._lang_index++;
     }
     else {
       return;
     }
   }
 }
 TokenizerBase.prototype.eatHexDigits = function() {
-  while (this._index < this._text.length) {
-    if (TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._index))) {
-      this._index++;
+  while (this._lang_index < this._text.length) {
+    if (TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._lang_index))) {
+      this._lang_index++;
     }
     else {
       return;
     }
   }
 }
 TokenizerBase.prototype.maybeEatHexDigit = function() {
-  if (this._index < this._text.length && TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._index))) {
-    this._index++;
+  if (this._lang_index < this._text.length && TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._lang_index))) {
+    this._lang_index++;
     return true;
   }
   return false;
 }
 TokenizerBase.prototype.finishHex = function() {
   this.eatHexDigits();
   return this._finishToken(61/*TokenKind.HEX_NUMBER*/);
 }
 TokenizerBase.prototype.finishNumber = function() {
   this.eatDigits();
   if (this._peekChar() == 46) {
     this._nextChar();
     if (TokenizerHelpers.isDigit(this._peekChar())) {
       this.eatDigits();
     }
     else {
-      this._index--;
+      this._lang_index--;
     }
   }
   return this.finishNumberExtra();
 }
 TokenizerBase.prototype.finishNumberExtra = function() {
   if (this._maybeEatChar(101) || this._maybeEatChar(69)) {
     this._maybeEatChar(45);
     this._maybeEatChar(43);
     this.eatDigits();
   }
@@ skipping 24 matching lines @@
     else if (ch == 92) {
       if (!this.eatEscapeSequence()) {
         return this._errorToken();
       }
     }
   }
 }
 TokenizerBase.prototype._finishOpenBrace = function() {
   var $0;
   if (this._interpStack != null) {
-    if (this._interpStack.depth == -1) {
+    if (this._interpStack.depth == -1.000000/*-1*/) {
       this._interpStack.depth = 1;
     }
     else {
       ($0 = this._interpStack).depth = $0.depth + 1;
     }
   }
   return this._finishToken(6/*TokenKind.LBRACE*/);
 }
 TokenizerBase.prototype._finishCloseBrace = function() {
   var $0;
@@ skipping 63 matching lines @@
       }
     }
   }
 }
 TokenizerBase.prototype.eatEscapeSequence = function() {
   var hex;
   switch (this._nextChar()) {
     case 120:
 
       return this.maybeEatHexDigit() && this.maybeEatHexDigit();
+      $throw(new FallThroughError("./tokenizer.dart", 336))
 
     case 117:
 
       if (this._maybeEatChar(123)) {
-        var start = this._index;
+        var start = this._lang_index;
         this.eatHexDigits();
-        var chars = this._index - start;
+        var chars = this._lang_index - start;
         if (chars > 0 && chars <= 6 && this._maybeEatChar(125)) {
           hex = this._text.substring(start, start + chars);
           break;
         }
         else {
           return false;
         }
       }
       else {
         if (this.maybeEatHexDigit() && this.maybeEatHexDigit() && this.maybeEatHexDigit() && this.maybeEatHexDigit()) {
-          hex = this._text.substring(this._index - 4, this._index);
+          hex = this._text.substring(this._lang_index - 4, this._lang_index);
           break;
         }
         else {
           return false;
         }
       }
+      $throw(new FallThroughError("./tokenizer.dart", 338))
 
     default:
 
       return true;
 
   }
-  var n = lang_Parser.parseHex(hex);
+  var n = Parser.parseHex(hex);
   return n < 0xD800 || n > 0xDFFF && n <= 0x10FFFF;
 }
 TokenizerBase.prototype.finishDot = function() {
   if (TokenizerHelpers.isDigit(this._peekChar())) {
     this.eatDigits();
     return this.finishNumberExtra();
   }
   else {
     return this._finishToken(14/*TokenKind.DOT*/);
   }
 }
 TokenizerBase.prototype.finishIdentifier = function() {
-  while (this._index < this._text.length) {
-    if (!TokenizerHelpers.isIdentifierPart(this._text.charCodeAt(this._index++))) {
-      this._index--;
+  while (this._lang_index < this._text.length) {
+    if (!TokenizerHelpers.isIdentifierPart(this._text.charCodeAt(this._lang_index++))) {
+      this._lang_index--;
       break;
     }
   }
   var kind = this.getIdentifierKind();
-  if (this._interpStack != null && this._interpStack.depth == -1) {
+  if (this._interpStack != null && this._interpStack.depth == -1.000000/*-1*/) {
     this._interpStack.depth = 0;
   }
   if (kind == 69/*TokenKind.IDENTIFIER*/) {
     return this._finishToken(69/*TokenKind.IDENTIFIER*/);
   }
   else {
     return this._finishToken(kind);
   }
 }
 // ********** Code for Tokenizer **************
 function Tokenizer(source, skipWhitespace, index) {
   TokenizerBase.call(this, source, skipWhitespace, index);
   // Initializers done
 }
 $inherits(Tokenizer, TokenizerBase);
 Tokenizer.prototype.next = function() {
-  this._startIndex = this._index;
+  this._startIndex = this._lang_index;
   if (this._interpStack != null && this._interpStack.depth == 0) {
     var istack = this._interpStack;
     this._interpStack = this._interpStack.pop();
     if (istack.isMultiline) {
       return this.finishMultilineString(istack.quote);
     }
     else {
       return this.finishStringBody(istack.quote);
     }
   }
   var ch;
   ch = this._nextChar();
   switch (ch) {
     case 0:
 
       return this._finishToken(1/*TokenKind.END_OF_FILE*/);
+      $throw(new FallThroughError("./tokenizer.g.dart", 29))
 
     case 32:
     case 9:
     case 10:
     case 13:
 
       return this.finishWhitespace();
+      $throw(new FallThroughError("./tokenizer.g.dart", 31))
 
     case 33:
 
       if (this._maybeEatChar(61)) {
         if (this._maybeEatChar(61)) {
           return this._finishToken(51/*TokenKind.NE_STRICT*/);
         }
         else {
           return this._finishToken(49/*TokenKind.NE*/);
         }
       }
       else {
         return this._finishToken(19/*TokenKind.NOT*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 33))
 
     case 34:
 
       return this.finishString(34);
+      $throw(new FallThroughError("./tokenizer.g.dart", 43))
 
     case 35:
 
       if (this._maybeEatChar(33)) {
         return this.finishHashBang();
       }
       else {
         return this._finishToken(12/*TokenKind.HASH*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 45))
 
     case 36:
 
       if (this._maybeEatChar(34)) {
         return this.finishString(34);
       }
       else if (this._maybeEatChar(39)) {
         return this.finishString(39);
       }
       else {
         return this.finishIdentifier();
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 51))
 
     case 37:
 
       if (this._maybeEatChar(61)) {
         return this._finishToken(32/*TokenKind.ASSIGN_MOD*/);
       }
       else {
         return this._finishToken(47/*TokenKind.MOD*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 59))
 
     case 38:
 
       if (this._maybeEatChar(38)) {
         return this._finishToken(35/*TokenKind.AND*/);
       }
       else if (this._maybeEatChar(61)) {
         return this._finishToken(23/*TokenKind.ASSIGN_AND*/);
       }
       else {
         return this._finishToken(38/*TokenKind.BIT_AND*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 65))
 
     case 39:
 
       return this.finishString(39);
+      $throw(new FallThroughError("./tokenizer.g.dart", 73))
 
     case 40:
 
       return this._finishToken(2/*TokenKind.LPAREN*/);
+      $throw(new FallThroughError("./tokenizer.g.dart", 75))
 
     case 41:
 
       return this._finishToken(3/*TokenKind.RPAREN*/);
+      $throw(new FallThroughError("./tokenizer.g.dart", 77))
 
     case 42:
 
       if (this._maybeEatChar(61)) {
         return this._finishToken(29/*TokenKind.ASSIGN_MUL*/);
       }
       else {
         return this._finishToken(44/*TokenKind.MUL*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 79))
 
     case 43:
 
       if (this._maybeEatChar(43)) {
         return this._finishToken(16/*TokenKind.INCR*/);
       }
       else if (this._maybeEatChar(61)) {
         return this._finishToken(27/*TokenKind.ASSIGN_ADD*/);
       }
       else {
         return this._finishToken(42/*TokenKind.ADD*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 85))
 
     case 44:
 
       return this._finishToken(11/*TokenKind.COMMA*/);
+      $throw(new FallThroughError("./tokenizer.g.dart", 93))
 
     case 45:
 
       if (this._maybeEatChar(45)) {
         return this._finishToken(17/*TokenKind.DECR*/);
       }
       else if (this._maybeEatChar(61)) {
         return this._finishToken(28/*TokenKind.ASSIGN_SUB*/);
       }
       else {
         return this._finishToken(43/*TokenKind.SUB*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 95))
 
     case 46:
 
       if (this._maybeEatChar(46)) {
         if (this._maybeEatChar(46)) {
           return this._finishToken(15/*TokenKind.ELLIPSIS*/);
         }
         else {
           return this._errorToken();
         }
       }
       else {
         return this.finishDot();
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 103))
 
     case 47:
 
       if (this._maybeEatChar(42)) {
         return this.finishMultiLineComment();
       }
       else if (this._maybeEatChar(47)) {
         return this.finishSingleLineComment();
       }
       else if (this._maybeEatChar(61)) {
         return this._finishToken(30/*TokenKind.ASSIGN_DIV*/);
       }
       else {
         return this._finishToken(45/*TokenKind.DIV*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 113))
 
     case 48:
 
       if (this._maybeEatChar(88)) {
         return this.finishHex();
       }
       else if (this._maybeEatChar(120)) {
         return this.finishHex();
       }
       else {
         return this.finishNumber();
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 123))
 
     case 58:
 
       return this._finishToken(8/*TokenKind.COLON*/);
+      $throw(new FallThroughError("./tokenizer.g.dart", 131))
 
     case 59:
 
       return this._finishToken(10/*TokenKind.SEMICOLON*/);
+      $throw(new FallThroughError("./tokenizer.g.dart", 133))
 
     case 60:
 
       if (this._maybeEatChar(60)) {
         if (this._maybeEatChar(61)) {
           return this._finishToken(24/*TokenKind.ASSIGN_SHL*/);
         }
         else {
           return this._finishToken(39/*TokenKind.SHL*/);
         }
       }
       else if (this._maybeEatChar(61)) {
         return this._finishToken(54/*TokenKind.LTE*/);
       }
       else {
         return this._finishToken(52/*TokenKind.LT*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 135))
 
     case 61:
 
       if (this._maybeEatChar(61)) {
         if (this._maybeEatChar(61)) {
           return this._finishToken(50/*TokenKind.EQ_STRICT*/);
         }
         else {
           return this._finishToken(48/*TokenKind.EQ*/);
         }
       }
       else if (this._maybeEatChar(62)) {
         return this._finishToken(9/*TokenKind.ARROW*/);
       }
       else {
         return this._finishToken(20/*TokenKind.ASSIGN*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 147))
 
     case 62:
 
       if (this._maybeEatChar(61)) {
         return this._finishToken(55/*TokenKind.GTE*/);
       }
       else if (this._maybeEatChar(62)) {
         if (this._maybeEatChar(61)) {
           return this._finishToken(25/*TokenKind.ASSIGN_SAR*/);
         }
         else if (this._maybeEatChar(62)) {
           if (this._maybeEatChar(61)) {
             return this._finishToken(26/*TokenKind.ASSIGN_SHR*/);
           }
           else {
             return this._finishToken(41/*TokenKind.SHR*/);
           }
         }
         else {
           return this._finishToken(40/*TokenKind.SAR*/);
         }
       }
       else {
         return this._finishToken(53/*TokenKind.GT*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 159))
 
     case 63:
 
       return this._finishToken(33/*TokenKind.CONDITIONAL*/);
+      $throw(new FallThroughError("./tokenizer.g.dart", 177))
 
     case 64:
 
       if (this._maybeEatChar(34)) {
         return this.finishRawString(34);
       }
       else if (this._maybeEatChar(39)) {
         return this.finishRawString(39);
       }
       else {
         return this._errorToken();
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 179))
 
     case 91:
 
       if (this._maybeEatChar(93)) {
         if (this._maybeEatChar(61)) {
           return this._finishToken(57/*TokenKind.SETINDEX*/);
         }
         else {
           return this._finishToken(56/*TokenKind.INDEX*/);
         }
       }
       else {
         return this._finishToken(4/*TokenKind.LBRACK*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 187))
 
     case 93:
 
       return this._finishToken(5/*TokenKind.RBRACK*/);
+      $throw(new FallThroughError("./tokenizer.g.dart", 197))
 
     case 94:
 
       if (this._maybeEatChar(61)) {
         return this._finishToken(22/*TokenKind.ASSIGN_XOR*/);
       }
       else {
         return this._finishToken(37/*TokenKind.BIT_XOR*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 199))
 
     case 123:
 
       return this._finishOpenBrace();
+      $throw(new FallThroughError("./tokenizer.g.dart", 205))
 
     case 124:
 
       if (this._maybeEatChar(61)) {
         return this._finishToken(21/*TokenKind.ASSIGN_OR*/);
       }
       else if (this._maybeEatChar(124)) {
         return this._finishToken(34/*TokenKind.OR*/);
       }
       else {
         return this._finishToken(36/*TokenKind.BIT_OR*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 207))
 
     case 125:
 
       return this._finishCloseBrace();
+      $throw(new FallThroughError("./tokenizer.g.dart", 215))
 
     case 126:
 
       if (this._maybeEatChar(47)) {
         if (this._maybeEatChar(61)) {
           return this._finishToken(31/*TokenKind.ASSIGN_TRUNCDIV*/);
         }
         else {
           return this._finishToken(46/*TokenKind.TRUNCDIV*/);
         }
       }
       else {
         return this._finishToken(18/*TokenKind.BIT_NOT*/);
       }
+      $throw(new FallThroughError("./tokenizer.g.dart", 217))
 
     default:
 
       if (TokenizerHelpers.isIdentifierStart(ch)) {
         return this.finishIdentifier();
       }
       else if (TokenizerHelpers.isDigit(ch)) {
         return this.finishNumber();
       }
       else {
         return this._errorToken();
       }
 
   }
 }
 Tokenizer.prototype.getIdentifierKind = function() {
   var i0 = this._startIndex;
-  switch (this._index - i0) {
+  switch (this._lang_index - i0) {
     case 2:
 
       if (this._text.charCodeAt(i0) == 100) {
         if (this._text.charCodeAt(i0 + 1) == 111) return 93/*TokenKind.DO*/;
       }
       else if (this._text.charCodeAt(i0) == 105) {
         if (this._text.charCodeAt(i0 + 1) == 102) {
           return 99/*TokenKind.IF*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 110) {
           return 100/*TokenKind.IN*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 115) {
           return 101/*TokenKind.IS*/;
         }
       }
       return 69/*TokenKind.IDENTIFIER*/;
+      $throw(new FallThroughError("./tokenizer.g.dart", 253))
 
     case 3:
 
       if (this._text.charCodeAt(i0) == 102) {
         if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 114) return 98/*TokenKind.FOR*/;
       }
       else if (this._text.charCodeAt(i0) == 103) {
         if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 75/*TokenKind.GET*/;
       }
       else if (this._text.charCodeAt(i0) == 110) {
         if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 119) return 102/*TokenKind.NEW*/;
       }
       else if (this._text.charCodeAt(i0) == 115) {
         if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 83/*TokenKind.SET*/;
       }
       else if (this._text.charCodeAt(i0) == 116) {
         if (this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 121) return 110/*TokenKind.TRY*/;
       }
       else if (this._text.charCodeAt(i0) == 118) {
         if (this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 114) return 111/*TokenKind.VAR*/;
       }
       return 69/*TokenKind.IDENTIFIER*/;
+      $throw(new FallThroughError("./tokenizer.g.dart", 268))
 
     case 4:
 
       if (this._text.charCodeAt(i0) == 99) {
         if (this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101) return 88/*TokenKind.CASE*/;
       }
       else if (this._text.charCodeAt(i0) == 101) {
         if (this._text.charCodeAt(i0 + 1) == 108 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101) return 94/*TokenKind.ELSE*/;
       }
       else if (this._text.charCodeAt(i0) == 110) {
         if (this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 108) return 103/*TokenKind.NULL*/;
       }
       else if (this._text.charCodeAt(i0) == 116) {
         if (this._text.charCodeAt(i0 + 1) == 104) {
           if (this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 115) return 107/*TokenKind.THIS*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 114) {
           if (this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 101) return 109/*TokenKind.TRUE*/;
         }
       }
       else if (this._text.charCodeAt(i0) == 118) {
         if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 100) return 112/*TokenKind.VOID*/;
       }
       return 69/*TokenKind.IDENTIFIER*/;
+      $throw(new FallThroughError("./tokenizer.g.dart", 285))
 
     case 5:
 
       if (this._text.charCodeAt(i0) == 98) {
         if (this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 101 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 107) return 87/*TokenKind.BREAK*/;
       }
       else if (this._text.charCodeAt(i0) == 99) {
         if (this._text.charCodeAt(i0 + 1) == 97) {
           if (this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 99 && this._text.charCodeAt(i0 + 4) == 104) return 89/*TokenKind.CATCH*/;
         }
@@ skipping 15 matching lines @@
       else if (this._text.charCodeAt(i0) == 115) {
         if (this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114) return 105/*TokenKind.SUPER*/;
       }
       else if (this._text.charCodeAt(i0) == 116) {
         if (this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 114 && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 119) return 108/*TokenKind.THROW*/;
       }
       else if (this._text.charCodeAt(i0) == 119) {
         if (this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101) return 113/*TokenKind.WHILE*/;
       }
       return 69/*TokenKind.IDENTIFIER*/;
+      $throw(new FallThroughError("./tokenizer.g.dart", 310))
 
     case 6:
 
       if (this._text.charCodeAt(i0) == 97) {
         if (this._text.charCodeAt(i0 + 1) == 115 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116) return 71/*TokenKind.ASSERT*/;
       }
       else if (this._text.charCodeAt(i0) == 105) {
         if (this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116) return 77/*TokenKind.IMPORT*/;
       }
       else if (this._text.charCodeAt(i0) == 110) {
@@ skipping 12 matching lines @@
           if (this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 101) return 84/*TokenKind.SOURCE*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 116) {
           if (this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 99) return 85/*TokenKind.STATIC*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 119) {
           if (this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 104) return 106/*TokenKind.SWITCH*/;
         }
       }
       return 69/*TokenKind.IDENTIFIER*/;
+      $throw(new FallThroughError("./tokenizer.g.dart", 333))
 
     case 7:
 
       if (this._text.charCodeAt(i0) == 100) {
         if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 102 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 117 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 116) return 92/*TokenKind.DEFAULT*/;
       }
       else if (this._text.charCodeAt(i0) == 101) {
         if (this._text.charCodeAt(i0 + 1) == 120 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 110 && this._text.charCodeAt(i0 + 5) == 100 && this._text.charCodeAt(i0 + 6) == 115) return 73/*TokenKind.EXTENDS*/;
       }
       else if (this._text.charCodeAt(i0) == 102) {
         if (this._text.charCodeAt(i0 + 1) == 97) {
           if (this._text.charCodeAt(i0 + 2) == 99 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 111 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121) return 74/*TokenKind.FACTORY*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 105) {
           if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 108 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 121) return 97/*TokenKind.FINALLY*/;
         }
       }
       else if (this._text.charCodeAt(i0) == 108) {
         if (this._text.charCodeAt(i0 + 1) == 105 && this._text.charCodeAt(i0 + 2) == 98 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121) return 79/*TokenKind.LIBRARY*/;
       }
       else if (this._text.charCodeAt(i0) == 116) {
         if (this._text.charCodeAt(i0 + 1) == 121 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 100 && this._text.charCodeAt(i0 + 5) == 101 && this._text.charCodeAt(i0 + 6) == 102) return 86/*TokenKind.TYPEDEF*/;
       }
       return 69/*TokenKind.IDENTIFIER*/;
+      $throw(new FallThroughError("./tokenizer.g.dart", 350))
 
     case 8:
 
       if (this._text.charCodeAt(i0) == 97) {
         if (this._text.charCodeAt(i0 + 1) == 98 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 97 && this._text.charCodeAt(i0 + 6) == 99 && this._text.charCodeAt(i0 + 7) == 116) return 70/*TokenKind.ABSTRACT*/;
       }
       else if (this._text.charCodeAt(i0) == 99) {
         if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 110 && this._text.charCodeAt(i0 + 6) == 117 && this._text.charCodeAt(i0 + 7) == 101) return 91/*TokenKind.CONTINUE*/;
       }
       else if (this._text.charCodeAt(i0) == 111) {
         if (this._text.charCodeAt(i0 + 1) == 112 && this._text.charCodeAt(i0 + 2) == 101 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 116 && this._text.charCodeAt(i0 + 6) == 111 && this._text.charCodeAt(i0 + 7) == 114) return 82/*TokenKind.OPERATOR*/;
       }
       return 69/*TokenKind.IDENTIFIER*/;
+      $throw(new FallThroughError("./tokenizer.g.dart", 359))
 
     case 9:
 
       if (this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 110 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 102 && this._text.charCodeAt(i0 + 6) == 97 && this._text.charCodeAt(i0 + 7) == 99 && this._text.charCodeAt(i0 + 8) == 101) return 78/*TokenKind.INTERFACE*/;
       return 69/*TokenKind.IDENTIFIER*/;
+      $throw(new FallThroughError("./tokenizer.g.dart", 362))
 
     case 10:
 
       if (this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101 && this._text.charCodeAt(i0 + 5) == 109 && this._text.charCodeAt(i0 + 6) == 101 && this._text.charCodeAt(i0 + 7) == 110 && this._text.charCodeAt(i0 + 8) == 116 && this._text.charCodeAt(i0 + 9) == 115) return 76/*TokenKind.IMPLEMENTS*/;
       return 69/*TokenKind.IDENTIFIER*/;
+      $throw(new FallThroughError("./tokenizer.g.dart", 365))
 
     default:
 
       return 69/*TokenKind.IDENTIFIER*/;
 
   }
 }
 // ********** Code for TokenizerHelpers **************
 function TokenizerHelpers() {}
 TokenizerHelpers.isIdentifierStart = function(c) {
@@ skipping 11 matching lines @@
 TokenizerHelpers.isIdentifierPart = function(c) {
   return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c));
 }
 // ********** Code for TokenKind **************
 function TokenKind() {}
 TokenKind.kindToString = function(kind) {
   switch (kind) {
     case 1/*TokenKind.END_OF_FILE*/:
 
       return "end of file";
+      $throw(new FallThroughError("./token_kind.g.dart", 347))
 
     case 2/*TokenKind.LPAREN*/:
 
       return "(";
+      $throw(new FallThroughError("./token_kind.g.dart", 348))
 
     case 3/*TokenKind.RPAREN*/:
 
       return ")";
+      $throw(new FallThroughError("./token_kind.g.dart", 349))
 
     case 4/*TokenKind.LBRACK*/:
 
       return "[";
+      $throw(new FallThroughError("./token_kind.g.dart", 350))
 
     case 5/*TokenKind.RBRACK*/:
 
       return "]";
+      $throw(new FallThroughError("./token_kind.g.dart", 351))
 
     case 6/*TokenKind.LBRACE*/:
 
       return "{";
+      $throw(new FallThroughError("./token_kind.g.dart", 352))
 
     case 7/*TokenKind.RBRACE*/:
 
       return "}";
+      $throw(new FallThroughError("./token_kind.g.dart", 353))
 
     case 8/*TokenKind.COLON*/:
 
       return ":";
+      $throw(new FallThroughError("./token_kind.g.dart", 354))
 
     case 9/*TokenKind.ARROW*/:
 
       return "=>";
+      $throw(new FallThroughError("./token_kind.g.dart", 355))
 
     case 10/*TokenKind.SEMICOLON*/:
 
       return ";";
+      $throw(new FallThroughError("./token_kind.g.dart", 356))
 
     case 11/*TokenKind.COMMA*/:
 
       return ",";
+      $throw(new FallThroughError("./token_kind.g.dart", 357))
 
     case 12/*TokenKind.HASH*/:
 
       return "#";
+      $throw(new FallThroughError("./token_kind.g.dart", 358))
 
     case 13/*TokenKind.HASHBANG*/:
 
       return "#!";
+      $throw(new FallThroughError("./token_kind.g.dart", 359))
 
     case 14/*TokenKind.DOT*/:
 
       return ".";
+      $throw(new FallThroughError("./token_kind.g.dart", 360))
 
     case 15/*TokenKind.ELLIPSIS*/:
 
       return "...";
+      $throw(new FallThroughError("./token_kind.g.dart", 361))
 
     case 16/*TokenKind.INCR*/:
 
       return "++";
+      $throw(new FallThroughError("./token_kind.g.dart", 362))
 
     case 17/*TokenKind.DECR*/:
 
       return "--";
+      $throw(new FallThroughError("./token_kind.g.dart", 363))
 
     case 18/*TokenKind.BIT_NOT*/:
 
       return "~";
+      $throw(new FallThroughError("./token_kind.g.dart", 364))
 
     case 19/*TokenKind.NOT*/:
 
       return "!";
+      $throw(new FallThroughError("./token_kind.g.dart", 365))
 
     case 20/*TokenKind.ASSIGN*/:
 
       return "=";
+      $throw(new FallThroughError("./token_kind.g.dart", 366))
 
     case 21/*TokenKind.ASSIGN_OR*/:
 
       return "|=";
+      $throw(new FallThroughError("./token_kind.g.dart", 367))
 
     case 22/*TokenKind.ASSIGN_XOR*/:
 
       return "^=";
+      $throw(new FallThroughError("./token_kind.g.dart", 368))
 
     case 23/*TokenKind.ASSIGN_AND*/:
 
       return "&=";
+      $throw(new FallThroughError("./token_kind.g.dart", 369))
 
     case 24/*TokenKind.ASSIGN_SHL*/:
 
       return "<<=";
+      $throw(new FallThroughError("./token_kind.g.dart", 370))
 
     case 25/*TokenKind.ASSIGN_SAR*/:
 
       return ">>=";
+      $throw(new FallThroughError("./token_kind.g.dart", 371))
 
     case 26/*TokenKind.ASSIGN_SHR*/:
 
       return ">>>=";
+      $throw(new FallThroughError("./token_kind.g.dart", 372))
 
     case 27/*TokenKind.ASSIGN_ADD*/:
 
       return "+=";
+      $throw(new FallThroughError("./token_kind.g.dart", 373))
 
     case 28/*TokenKind.ASSIGN_SUB*/:
 
       return "-=";
+      $throw(new FallThroughError("./token_kind.g.dart", 374))
 
     case 29/*TokenKind.ASSIGN_MUL*/:
 
       return "*=";
+      $throw(new FallThroughError("./token_kind.g.dart", 375))
 
     case 30/*TokenKind.ASSIGN_DIV*/:
 
       return "/=";
+      $throw(new FallThroughError("./token_kind.g.dart", 376))
 
     case 31/*TokenKind.ASSIGN_TRUNCDIV*/:
 
       return "~/=";
+      $throw(new FallThroughError("./token_kind.g.dart", 377))
 
     case 32/*TokenKind.ASSIGN_MOD*/:
 
       return "%=";
+      $throw(new FallThroughError("./token_kind.g.dart", 378))
 
     case 33/*TokenKind.CONDITIONAL*/:
 
       return "?";
+      $throw(new FallThroughError("./token_kind.g.dart", 379))
 
     case 34/*TokenKind.OR*/:
 
       return "||";
+      $throw(new FallThroughError("./token_kind.g.dart", 380))
 
     case 35/*TokenKind.AND*/:
 
       return "&&";
+      $throw(new FallThroughError("./token_kind.g.dart", 381))
 
     case 36/*TokenKind.BIT_OR*/:
 
       return "|";
+      $throw(new FallThroughError("./token_kind.g.dart", 382))
 
     case 37/*TokenKind.BIT_XOR*/:
 
       return "^";
+      $throw(new FallThroughError("./token_kind.g.dart", 383))
 
     case 38/*TokenKind.BIT_AND*/:
 
       return "&";
+      $throw(new FallThroughError("./token_kind.g.dart", 384))
 
     case 39/*TokenKind.SHL*/:
 
       return "<<";
+      $throw(new FallThroughError("./token_kind.g.dart", 385))
 
     case 40/*TokenKind.SAR*/:
 
       return ">>";
+      $throw(new FallThroughError("./token_kind.g.dart", 386))
 
     case 41/*TokenKind.SHR*/:
 
       return ">>>";
+      $throw(new FallThroughError("./token_kind.g.dart", 387))
 
     case 42/*TokenKind.ADD*/:
 
       return "+";
+      $throw(new FallThroughError("./token_kind.g.dart", 388))
 
     case 43/*TokenKind.SUB*/:
 
       return "-";
+      $throw(new FallThroughError("./token_kind.g.dart", 389))
 
     case 44/*TokenKind.MUL*/:
 
       return "*";
+      $throw(new FallThroughError("./token_kind.g.dart", 390))
 
     case 45/*TokenKind.DIV*/:
 
       return "/";
+      $throw(new FallThroughError("./token_kind.g.dart", 391))
 
     case 46/*TokenKind.TRUNCDIV*/:
 
       return "~/";
+      $throw(new FallThroughError("./token_kind.g.dart", 392))
 
     case 47/*TokenKind.MOD*/:
 
       return "%";
+      $throw(new FallThroughError("./token_kind.g.dart", 393))
 
     case 48/*TokenKind.EQ*/:
 
       return "==";
+      $throw(new FallThroughError("./token_kind.g.dart", 394))
 
     case 49/*TokenKind.NE*/:
 
       return "!=";
+      $throw(new FallThroughError("./token_kind.g.dart", 395))
 
     case 50/*TokenKind.EQ_STRICT*/:
 
       return "===";
+      $throw(new FallThroughError("./token_kind.g.dart", 396))
 
     case 51/*TokenKind.NE_STRICT*/:
 
       return "!==";
+      $throw(new FallThroughError("./token_kind.g.dart", 397))
 
     case 52/*TokenKind.LT*/:
 
       return "<";
+      $throw(new FallThroughError("./token_kind.g.dart", 398))
 
     case 53/*TokenKind.GT*/:
 
       return ">";
+      $throw(new FallThroughError("./token_kind.g.dart", 399))
 
     case 54/*TokenKind.LTE*/:
 
       return "<=";
+      $throw(new FallThroughError("./token_kind.g.dart", 400))
 
     case 55/*TokenKind.GTE*/:
 
       return ">=";
+      $throw(new FallThroughError("./token_kind.g.dart", 401))
 
     case 56/*TokenKind.INDEX*/:
 
       return "[]";
+      $throw(new FallThroughError("./token_kind.g.dart", 402))
 
     case 57/*TokenKind.SETINDEX*/:
 
       return "[]=";
+      $throw(new FallThroughError("./token_kind.g.dart", 403))
 
     case 58/*TokenKind.STRING*/:
 
       return "string";
+      $throw(new FallThroughError("./token_kind.g.dart", 404))
 
     case 59/*TokenKind.STRING_PART*/:
 
       return "string part";
+      $throw(new FallThroughError("./token_kind.g.dart", 405))
 
     case 60/*TokenKind.NUMBER*/:
 
       return "number";
+      $throw(new FallThroughError("./token_kind.g.dart", 406))
 
     case 61/*TokenKind.HEX_NUMBER*/:
 
       return "hex number";
+      $throw(new FallThroughError("./token_kind.g.dart", 407))
 
     case 62/*TokenKind.WHITESPACE*/:
 
       return "whitespace";
+      $throw(new FallThroughError("./token_kind.g.dart", 408))
 
     case 63/*TokenKind.COMMENT*/:
 
       return "comment";
+      $throw(new FallThroughError("./token_kind.g.dart", 409))
 
     case 64/*TokenKind.ERROR*/:
 
       return "error";
+      $throw(new FallThroughError("./token_kind.g.dart", 410))
 
     case 65/*TokenKind.INCOMPLETE_STRING*/:
 
       return "incomplete string";
+      $throw(new FallThroughError("./token_kind.g.dart", 411))
 
     case 66/*TokenKind.INCOMPLETE_COMMENT*/:
 
       return "incomplete comment";
+      $throw(new FallThroughError("./token_kind.g.dart", 412))
 
     case 67/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/:
 
       return "incomplete multiline string dq";
+      $throw(new FallThroughError("./token_kind.g.dart", 413))
 
     case 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/:
 
       return "incomplete multiline string sq";
+      $throw(new FallThroughError("./token_kind.g.dart", 414))
 
     case 69/*TokenKind.IDENTIFIER*/:
 
       return "identifier";
+      $throw(new FallThroughError("./token_kind.g.dart", 415))
 
     case 70/*TokenKind.ABSTRACT*/:
 
       return "pseudo-keyword 'abstract'";
+      $throw(new FallThroughError("./token_kind.g.dart", 416))
 
     case 71/*TokenKind.ASSERT*/:
 
       return "pseudo-keyword 'assert'";
+      $throw(new FallThroughError("./token_kind.g.dart", 417))
 
     case 72/*TokenKind.CLASS*/:
 
       return "pseudo-keyword 'class'";
+      $throw(new FallThroughError("./token_kind.g.dart", 418))
 
     case 73/*TokenKind.EXTENDS*/:
 
       return "pseudo-keyword 'extends'";
+      $throw(new FallThroughError("./token_kind.g.dart", 419))
 
     case 74/*TokenKind.FACTORY*/:
 
       return "pseudo-keyword 'factory'";
+      $throw(new FallThroughError("./token_kind.g.dart", 420))
 
     case 75/*TokenKind.GET*/:
 
       return "pseudo-keyword 'get'";
+      $throw(new FallThroughError("./token_kind.g.dart", 421))
 
     case 76/*TokenKind.IMPLEMENTS*/:
 
       return "pseudo-keyword 'implements'";
+      $throw(new FallThroughError("./token_kind.g.dart", 422))
 
     case 77/*TokenKind.IMPORT*/:
 
       return "pseudo-keyword 'import'";
+      $throw(new FallThroughError("./token_kind.g.dart", 423))
 
     case 78/*TokenKind.INTERFACE*/:
 
       return "pseudo-keyword 'interface'";
+      $throw(new FallThroughError("./token_kind.g.dart", 424))
 
     case 79/*TokenKind.LIBRARY*/:
 
       return "pseudo-keyword 'library'";
+      $throw(new FallThroughError("./token_kind.g.dart", 425))
 
     case 80/*TokenKind.NATIVE*/:
 
       return "pseudo-keyword 'native'";
+      $throw(new FallThroughError("./token_kind.g.dart", 426))
 
     case 81/*TokenKind.NEGATE*/:
 
       return "pseudo-keyword 'negate'";
+      $throw(new FallThroughError("./token_kind.g.dart", 427))
 
     case 82/*TokenKind.OPERATOR*/:
 
       return "pseudo-keyword 'operator'";
+      $throw(new FallThroughError("./token_kind.g.dart", 428))
 
     case 83/*TokenKind.SET*/:
 
       return "pseudo-keyword 'set'";
+      $throw(new FallThroughError("./token_kind.g.dart", 429))
 
     case 84/*TokenKind.SOURCE*/:
 
       return "pseudo-keyword 'source'";
+      $throw(new FallThroughError("./token_kind.g.dart", 430))
 
     case 85/*TokenKind.STATIC*/:
 
       return "pseudo-keyword 'static'";
+      $throw(new FallThroughError("./token_kind.g.dart", 431))
 
     case 86/*TokenKind.TYPEDEF*/:
 
       return "pseudo-keyword 'typedef'";
+      $throw(new FallThroughError("./token_kind.g.dart", 432))
 
     case 87/*TokenKind.BREAK*/:
 
       return "keyword 'break'";
+      $throw(new FallThroughError("./token_kind.g.dart", 433))
 
     case 88/*TokenKind.CASE*/:
 
       return "keyword 'case'";
+      $throw(new FallThroughError("./token_kind.g.dart", 434))
 
     case 89/*TokenKind.CATCH*/:
 
       return "keyword 'catch'";
+      $throw(new FallThroughError("./token_kind.g.dart", 435))
 
     case 90/*TokenKind.CONST*/:
 
       return "keyword 'const'";
+      $throw(new FallThroughError("./token_kind.g.dart", 436))
 
     case 91/*TokenKind.CONTINUE*/:
 
       return "keyword 'continue'";
+      $throw(new FallThroughError("./token_kind.g.dart", 437))
 
     case 92/*TokenKind.DEFAULT*/:
 
       return "keyword 'default'";
+      $throw(new FallThroughError("./token_kind.g.dart", 438))
 
     case 93/*TokenKind.DO*/:
 
       return "keyword 'do'";
+      $throw(new FallThroughError("./token_kind.g.dart", 439))
 
     case 94/*TokenKind.ELSE*/:
 
       return "keyword 'else'";
+      $throw(new FallThroughError("./token_kind.g.dart", 440))
 
     case 95/*TokenKind.FALSE*/:
 
       return "keyword 'false'";
+      $throw(new FallThroughError("./token_kind.g.dart", 441))
 
     case 96/*TokenKind.FINAL*/:
 
       return "keyword 'final'";
+      $throw(new FallThroughError("./token_kind.g.dart", 442))
 
     case 97/*TokenKind.FINALLY*/:
 
       return "keyword 'finally'";
+      $throw(new FallThroughError("./token_kind.g.dart", 443))
 
     case 98/*TokenKind.FOR*/:
 
       return "keyword 'for'";
+      $throw(new FallThroughError("./token_kind.g.dart", 444))
 
     case 99/*TokenKind.IF*/:
 
       return "keyword 'if'";
+      $throw(new FallThroughError("./token_kind.g.dart", 445))
 
     case 100/*TokenKind.IN*/:
 
       return "keyword 'in'";
+      $throw(new FallThroughError("./token_kind.g.dart", 446))
 
     case 101/*TokenKind.IS*/:
 
       return "keyword 'is'";
+      $throw(new FallThroughError("./token_kind.g.dart", 447))
 
     case 102/*TokenKind.NEW*/:
 
       return "keyword 'new'";
+      $throw(new FallThroughError("./token_kind.g.dart", 448))
 
     case 103/*TokenKind.NULL*/:
 
       return "keyword 'null'";
+      $throw(new FallThroughError("./token_kind.g.dart", 449))
 
     case 104/*TokenKind.RETURN*/:
 
       return "keyword 'return'";
+      $throw(new FallThroughError("./token_kind.g.dart", 450))
 
     case 105/*TokenKind.SUPER*/:
 
       return "keyword 'super'";
+      $throw(new FallThroughError("./token_kind.g.dart", 451))
 
     case 106/*TokenKind.SWITCH*/:
 
       return "keyword 'switch'";
+      $throw(new FallThroughError("./token_kind.g.dart", 452))
 
     case 107/*TokenKind.THIS*/:
 
       return "keyword 'this'";
+      $throw(new FallThroughError("./token_kind.g.dart", 453))
 
     case 108/*TokenKind.THROW*/:
 
       return "keyword 'throw'";
+      $throw(new FallThroughError("./token_kind.g.dart", 454))
 
     case 109/*TokenKind.TRUE*/:
 
       return "keyword 'true'";
+      $throw(new FallThroughError("./token_kind.g.dart", 455))
 
     case 110/*TokenKind.TRY*/:
 
       return "keyword 'try'";
+      $throw(new FallThroughError("./token_kind.g.dart", 456))
 
     case 111/*TokenKind.VAR*/:
 
       return "keyword 'var'";
+      $throw(new FallThroughError("./token_kind.g.dart", 457))
 
     case 112/*TokenKind.VOID*/:
 
       return "keyword 'void'";
+      $throw(new FallThroughError("./token_kind.g.dart", 458))
 
     case 113/*TokenKind.WHILE*/:
 
       return "keyword 'while'";
+      $throw(new FallThroughError("./token_kind.g.dart", 459))
 
     default:
 
       return "TokenKind(" + kind.toString() + ")";
 
   }
 }
 TokenKind.isIdentifier = function(kind) {
   return kind >= 69/*TokenKind.IDENTIFIER*/ && kind < 87/*TokenKind.BREAK*/;
 }
 TokenKind.infixPrecedence = function(kind) {
   switch (kind) {
     case 20/*TokenKind.ASSIGN*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 470))
 
     case 21/*TokenKind.ASSIGN_OR*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 471))
 
     case 22/*TokenKind.ASSIGN_XOR*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 472))
 
     case 23/*TokenKind.ASSIGN_AND*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 473))
 
     case 24/*TokenKind.ASSIGN_SHL*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 474))
 
     case 25/*TokenKind.ASSIGN_SAR*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 475))
 
     case 26/*TokenKind.ASSIGN_SHR*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 476))
 
     case 27/*TokenKind.ASSIGN_ADD*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 477))
 
     case 28/*TokenKind.ASSIGN_SUB*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 478))
 
     case 29/*TokenKind.ASSIGN_MUL*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 479))
 
     case 30/*TokenKind.ASSIGN_DIV*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 480))
 
     case 31/*TokenKind.ASSIGN_TRUNCDIV*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 481))
 
     case 32/*TokenKind.ASSIGN_MOD*/:
 
       return 2;
+      $throw(new FallThroughError("./token_kind.g.dart", 482))
 
     case 33/*TokenKind.CONDITIONAL*/:
 
       return 3;
+      $throw(new FallThroughError("./token_kind.g.dart", 483))
 
     case 34/*TokenKind.OR*/:
 
       return 4;
+      $throw(new FallThroughError("./token_kind.g.dart", 484))
 
     case 35/*TokenKind.AND*/:
 
       return 5;
+      $throw(new FallThroughError("./token_kind.g.dart", 485))
 
     case 36/*TokenKind.BIT_OR*/:
 
       return 6;
+      $throw(new FallThroughError("./token_kind.g.dart", 486))
 
     case 37/*TokenKind.BIT_XOR*/:
 
       return 7;
+      $throw(new FallThroughError("./token_kind.g.dart", 487))
 
     case 38/*TokenKind.BIT_AND*/:
 
       return 8;
+      $throw(new FallThroughError("./token_kind.g.dart", 488))
 
     case 39/*TokenKind.SHL*/:
 
       return 11;
+      $throw(new FallThroughError("./token_kind.g.dart", 489))
 
     case 40/*TokenKind.SAR*/:
 
       return 11;
+      $throw(new FallThroughError("./token_kind.g.dart", 490))
 
     case 41/*TokenKind.SHR*/:
 
       return 11;
+      $throw(new FallThroughError("./token_kind.g.dart", 491))
 
     case 42/*TokenKind.ADD*/:
 
       return 12;
+      $throw(new FallThroughError("./token_kind.g.dart", 492))
 
     case 43/*TokenKind.SUB*/:
 
       return 12;
+      $throw(new FallThroughError("./token_kind.g.dart", 493))
 
     case 44/*TokenKind.MUL*/:
 
       return 13;
+      $throw(new FallThroughError("./token_kind.g.dart", 494))
 
     case 45/*TokenKind.DIV*/:
 
       return 13;
+      $throw(new FallThroughError("./token_kind.g.dart", 495))
 
     case 46/*TokenKind.TRUNCDIV*/:
 
       return 13;
+      $throw(new FallThroughError("./token_kind.g.dart", 496))
 
     case 47/*TokenKind.MOD*/:
 
       return 13;
+      $throw(new FallThroughError("./token_kind.g.dart", 497))
 
     case 48/*TokenKind.EQ*/:
 
       return 9;
+      $throw(new FallThroughError("./token_kind.g.dart", 498))
 
     case 49/*TokenKind.NE*/:
 
       return 9;
+      $throw(new FallThroughError("./token_kind.g.dart", 499))
 
     case 50/*TokenKind.EQ_STRICT*/:
 
       return 9;
+      $throw(new FallThroughError("./token_kind.g.dart", 500))
 
     case 51/*TokenKind.NE_STRICT*/:
 
       return 9;
+      $throw(new FallThroughError("./token_kind.g.dart", 501))
 
     case 52/*TokenKind.LT*/:
 
       return 10;
+      $throw(new FallThroughError("./token_kind.g.dart", 502))
 
     case 53/*TokenKind.GT*/:
 
       return 10;
+      $throw(new FallThroughError("./token_kind.g.dart", 503))
 
     case 54/*TokenKind.LTE*/:
 
       return 10;
+      $throw(new FallThroughError("./token_kind.g.dart", 504))
 
     case 55/*TokenKind.GTE*/:
 
       return 10;
+      $throw(new FallThroughError("./token_kind.g.dart", 505))
 
     case 101/*TokenKind.IS*/:
 
       return 10;
+      $throw(new FallThroughError("./token_kind.g.dart", 506))
 
     default:
 
-      return -1;
+      return -1.000000/*-1*/;
 
   }
 }
 TokenKind.rawOperatorFromMethod = function(name) {
   switch (name) {
     case '\$bit_not':
 
       return '~';
+      $throw(new FallThroughError("./token_kind.g.dart", 513))
 
     case '\$bit_or':
 
       return '|';
+      $throw(new FallThroughError("./token_kind.g.dart", 514))
 
     case '\$bit_xor':
 
       return '^';
+      $throw(new FallThroughError("./token_kind.g.dart", 515))
 
     case '\$bit_and':
 
       return '&';
+      $throw(new FallThroughError("./token_kind.g.dart", 516))
 
     case '\$shl':
 
       return '<<';
+      $throw(new FallThroughError("./token_kind.g.dart", 517))
 
     case '\$sar':
 
       return '>>';
+      $throw(new FallThroughError("./token_kind.g.dart", 518))
 
     case '\$shr':
 
       return '>>>';
+      $throw(new FallThroughError("./token_kind.g.dart", 519))
 
     case '\$add':
 
       return '+';
+      $throw(new FallThroughError("./token_kind.g.dart", 520))
 
     case '\$sub':
 
       return '-';
+      $throw(new FallThroughError("./token_kind.g.dart", 521))
 
     case '\$mul':
 
       return '*';
+      $throw(new FallThroughError("./token_kind.g.dart", 522))
 
     case '\$div':
 
       return '/';
+      $throw(new FallThroughError("./token_kind.g.dart", 523))
 
     case '\$truncdiv':
 
       return '~/';
+      $throw(new FallThroughError("./token_kind.g.dart", 524))
 
     case '\$mod':
 
       return '%';
+      $throw(new FallThroughError("./token_kind.g.dart", 525))
 
     case '\$eq':
 
       return '==';
+      $throw(new FallThroughError("./token_kind.g.dart", 526))
 
     case '\$lt':
 
       return '<';
+      $throw(new FallThroughError("./token_kind.g.dart", 527))
 
     case '\$gt':
 
       return '>';
+      $throw(new FallThroughError("./token_kind.g.dart", 528))
 
     case '\$lte':
 
       return '<=';
+      $throw(new FallThroughError("./token_kind.g.dart", 529))
 
     case '\$gte':
 
       return '>=';
+      $throw(new FallThroughError("./token_kind.g.dart", 530))
 
     case '\$index':
 
       return '[]';
+      $throw(new FallThroughError("./token_kind.g.dart", 531))
 
     case '\$setindex':
 
       return '[]=';
+      $throw(new FallThroughError("./token_kind.g.dart", 532))
 
     case '\$ne':
 
       return '!=';
 
   }
 }
 TokenKind.binaryMethodName = function(kind) {
   switch (kind) {
     case 18/*TokenKind.BIT_NOT*/:
 
       return '\$bit_not';
+      $throw(new FallThroughError("./token_kind.g.dart", 539))
 
     case 36/*TokenKind.BIT_OR*/:
 
       return '\$bit_or';
+      $throw(new FallThroughError("./token_kind.g.dart", 540))
 
     case 37/*TokenKind.BIT_XOR*/:
 
       return '\$bit_xor';
+      $throw(new FallThroughError("./token_kind.g.dart", 541))
 
     case 38/*TokenKind.BIT_AND*/:
 
       return '\$bit_and';
+      $throw(new FallThroughError("./token_kind.g.dart", 542))
 
     case 39/*TokenKind.SHL*/:
 
       return '\$shl';
+      $throw(new FallThroughError("./token_kind.g.dart", 543))
 
     case 40/*TokenKind.SAR*/:
 
       return '\$sar';
+      $throw(new FallThroughError("./token_kind.g.dart", 544))
 
     case 41/*TokenKind.SHR*/:
 
       return '\$shr';
+      $throw(new FallThroughError("./token_kind.g.dart", 545))
 
     case 42/*TokenKind.ADD*/:
 
       return '\$add';
+      $throw(new FallThroughError("./token_kind.g.dart", 546))
 
     case 43/*TokenKind.SUB*/:
 
       return '\$sub';
+      $throw(new FallThroughError("./token_kind.g.dart", 547))
 
     case 44/*TokenKind.MUL*/:
 
       return '\$mul';
+      $throw(new FallThroughError("./token_kind.g.dart", 548))
 
     case 45/*TokenKind.DIV*/:
 
       return '\$div';
+      $throw(new FallThroughError("./token_kind.g.dart", 549))
 
     case 46/*TokenKind.TRUNCDIV*/:
 
       return '\$truncdiv';
+      $throw(new FallThroughError("./token_kind.g.dart", 550))
 
     case 47/*TokenKind.MOD*/:
 
       return '\$mod';
+      $throw(new FallThroughError("./token_kind.g.dart", 551))
 
     case 48/*TokenKind.EQ*/:
 
       return '\$eq';
+      $throw(new FallThroughError("./token_kind.g.dart", 552))
 
     case 52/*TokenKind.LT*/:
 
       return '\$lt';
+      $throw(new FallThroughError("./token_kind.g.dart", 553))
 
     case 53/*TokenKind.GT*/:
 
       return '\$gt';
+      $throw(new FallThroughError("./token_kind.g.dart", 554))
 
     case 54/*TokenKind.LTE*/:
 
       return '\$lte';
+      $throw(new FallThroughError("./token_kind.g.dart", 555))
 
     case 55/*TokenKind.GTE*/:
 
       return '\$gte';
+      $throw(new FallThroughError("./token_kind.g.dart", 556))
 
     case 56/*TokenKind.INDEX*/:
 
       return '\$index';
+      $throw(new FallThroughError("./token_kind.g.dart", 557))
 
     case 57/*TokenKind.SETINDEX*/:
 
       return '\$setindex';
 
   }
 }
 TokenKind.kindFromAssign = function(kind) {
   if (kind == 20/*TokenKind.ASSIGN*/) return 0;
   if (kind > 20/*TokenKind.ASSIGN*/ && kind <= 32/*TokenKind.ASSIGN_MOD*/) {
-    return kind + (15)/*(ADD - ASSIGN_ADD)*/;
+    return kind + (15.000000)/*(ADD - ASSIGN_ADD)*/;
   }
-  return -1;
+  return -1.000000/*-1*/;
 }
-// ********** Code for lang_Parser **************
-function lang_Parser(source, diet, startOffset) {
+// ********** Code for Parser **************
+function Parser(source, diet, startOffset) {
   this.source = source;
   this.diet = diet;
   // Initializers done
   this.tokenizer = new Tokenizer(this.source, true, startOffset);
   this._peekToken = this.tokenizer.next();
   this._previousToken = null;
   this._inInitializers = false;
 }
-lang_Parser.prototype.isPrematureEndOfFile = function() {
+Parser.prototype.isPrematureEndOfFile = function() {
   if (this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
     this._lang_error('unexpected end of file', this._peekToken.get$span());
     return true;
   }
   else {
     return false;
   }
 }
-lang_Parser.prototype._peek = function() {
+Parser.prototype._peek = function() {
   return this._peekToken.kind;
 }
-lang_Parser.prototype._lang_next = function() {
+Parser.prototype._lang_next = function() {
   this._previousToken = this._peekToken;
   this._peekToken = this.tokenizer.next();
   return this._previousToken;
 }
-lang_Parser.prototype._peekKind = function(kind) {
+Parser.prototype._peekKind = function(kind) {
   return this._peekToken.kind == kind;
 }
-lang_Parser.prototype._peekIdentifier = function() {
+Parser.prototype._peekIdentifier = function() {
   return TokenKind.isIdentifier(this._peekToken.kind);
 }
-lang_Parser.prototype._maybeEat = function(kind) {
+Parser.prototype._maybeEat = function(kind) {
   if (this._peekToken.kind == kind) {
     this._previousToken = this._peekToken;
     this._peekToken = this.tokenizer.next();
     return true;
   }
   else {
     return false;
   }
 }
-lang_Parser.prototype._eat = function(kind) {
+Parser.prototype._eat = function(kind) {
   if (!this._maybeEat(kind)) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
 }
-lang_Parser.prototype._eatSemicolon = function() {
+Parser.prototype._eatSemicolon = function() {
   this._eat(10/*TokenKind.SEMICOLON*/);
 }
-lang_Parser.prototype._errorExpected = function(expected) {
+Parser.prototype._errorExpected = function(expected) {
   var tok = this._lang_next();
   var message = ('expected ' + expected + ', but found ' + tok + '');
   this._lang_error(message, tok.get$span());
 }
-lang_Parser.prototype._lang_error = function(message, location) {
+Parser.prototype._lang_error = function(message, location) {
   if (location == null) {
     location = this._peekToken.get$span();
   }
   world.fatal(message, location);
 }
-lang_Parser.prototype._skipBlock = function() {
+Parser.prototype._skipBlock = function() {
   var depth = 1;
   this._eat(6/*TokenKind.LBRACE*/);
   while (true) {
     var tok = this._lang_next();
     if (tok.kind == 6/*TokenKind.LBRACE*/) {
       depth += 1;
     }
     else if (tok.kind == 7/*TokenKind.RBRACE*/) {
       depth -= 1;
       if (depth == 0) return;
     }
     else if (tok.kind == 1/*TokenKind.END_OF_FILE*/) {
       this._lang_error('unexpected end of file during diet parse', tok.get$span());
       return;
     }
   }
 }
-lang_Parser.prototype._makeSpan = function(start) {
+Parser.prototype._makeSpan = function(start) {
   return new SourceSpan(this.source, start, this._previousToken.end);
 }
-lang_Parser.prototype.compilationUnit = function() {
+Parser.prototype.compilationUnit = function() {
   var ret = [];
   this._maybeEat(13/*TokenKind.HASHBANG*/);
   while (this._peekKind(12/*TokenKind.HASH*/)) {
     ret.add(this.directive());
   }
   while (!this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
     ret.add(this.topLevelDefinition());
   }
   return ret;
 }
-lang_Parser.prototype.directive = function() {
+Parser.prototype.directive = function() {
   var start = this._peekToken.start;
   this._eat(12/*TokenKind.HASH*/);
   var name = this.identifier();
   var args = this.arguments();
   this._eatSemicolon();
   return new DirectiveDefinition(name, args, this._makeSpan(start));
 }
-lang_Parser.prototype.topLevelDefinition = function() {
+Parser.prototype.topLevelDefinition = function() {
   switch (this._peek()) {
     case 72/*TokenKind.CLASS*/:
 
       return this.classDefinition(72/*TokenKind.CLASS*/);
+      $throw(new FallThroughError("./parser.dart", 157))
 
     case 78/*TokenKind.INTERFACE*/:
 
       return this.classDefinition(78/*TokenKind.INTERFACE*/);
+      $throw(new FallThroughError("./parser.dart", 159))
 
     case 86/*TokenKind.TYPEDEF*/:
 
       return this.functionTypeAlias();
+      $throw(new FallThroughError("./parser.dart", 161))
 
     default:
 
       return this.declaration();
 
   }
 }
-lang_Parser.prototype.classDefinition = function(kind) {
+Parser.prototype.classDefinition = function(kind) {
   var start = this._peekToken.start;
   this._eat(kind);
   var name = this.identifier();
   var typeParams = null;
   if (this._peekKind(52/*TokenKind.LT*/)) {
     typeParams = this.typeParameters();
   }
   var _extends = null;
   if (this._maybeEat(73/*TokenKind.EXTENDS*/)) {
     _extends = this.typeList();
@@ skipping 15 matching lines @@
     while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
       if (this.isPrematureEndOfFile()) break;
       body.add(this.declaration());
     }
   }
   else {
     this._errorExpected('block starting with "{" or ";"');
   }
   return new TypeDefinition(kind == 72/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, _factory, body, this._makeSpan(start));
 }
-lang_Parser.prototype.functionTypeAlias = function() {
+Parser.prototype.functionTypeAlias = function() {
   var start = this._peekToken.start;
   this._eat(86/*TokenKind.TYPEDEF*/);
   var di = this.declaredIdentifier(false);
   var typeParams = null;
   if (this._peekKind(52/*TokenKind.LT*/)) {
     typeParams = this.typeParameters();
   }
   var formals = this.formalParameterList();
   this._eatSemicolon();
   var func = new FunctionDefinition(null, di.type, di.get$name(), formals, null, null, this._makeSpan(start));
   return new FunctionTypeDefinition(func, typeParams, this._makeSpan(start));
 }
-lang_Parser.prototype.initializers = function() {
+Parser.prototype.initializers = function() {
   this._inInitializers = true;
   var ret = [];
   do {
     ret.add(this.expression());
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   this._inInitializers = false;
   return ret;
 }
-lang_Parser.prototype.functionBody = function(inExpression) {
+Parser.prototype.functionBody = function(inExpression) {
   var start = this._peekToken.start;
   if (this._maybeEat(9/*TokenKind.ARROW*/)) {
     var expr = this.expression();
     if (!inExpression) {
       this._eatSemicolon();
     }
     return new ReturnStatement(expr, this._makeSpan(start));
   }
   else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
     if (this.diet) {
@@ skipping 14 matching lines @@
         this._eatSemicolon();
         return new NativeStatement(nativeBody, this._makeSpan(start));
       }
       else {
         return this.functionBody(inExpression);
       }
     }
   }
   this._lang_error('Expected function body (neither { nor => found)');
 }
-lang_Parser.prototype.finishField = function(start, modifiers, type, name, value) {
+Parser.prototype.finishField = function(start, modifiers, type, name, value) {
   var names = [name];
   var values = [value];
   while (this._maybeEat(11/*TokenKind.COMMA*/)) {
     names.add(this.identifier());
     if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
       values.add(this.expression());
     }
     else {
       values.add(null);
     }
   }
   this._eatSemicolon();
   return new VariableDefinition(modifiers, type, names, values, this._makeSpan(start));
 }
-lang_Parser.prototype.finishDefinition = function(start, modifiers, di) {
+Parser.prototype.finishDefinition = function(start, modifiers, di) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       var formals = this.formalParameterList();
       var inits = null;
       if (this._maybeEat(8/*TokenKind.COLON*/)) {
         inits = this.initializers();
       }
       var body = this.functionBody(false);
       if (di.get$name() == null) {
         di.name = di.type.get$name();
       }
       return new FunctionDefinition(modifiers, di.type, di.get$name(), formals, inits, body, this._makeSpan(start));
+      $throw(new FallThroughError("./parser.dart", 307))
 
     case 20/*TokenKind.ASSIGN*/:
 
       this._eat(20/*TokenKind.ASSIGN*/);
       var value = this.expression();
       return this.finishField(start, modifiers, di.type, di.get$name(), value);
+      $throw(new FallThroughError("./parser.dart", 313))
 
     case 11/*TokenKind.COMMA*/:
     case 10/*TokenKind.SEMICOLON*/:
 
       return this.finishField(start, modifiers, di.type, di.get$name(), null);
+      $throw(new FallThroughError("./parser.dart", 317))
 
     default:
 
       this._errorExpected('declaration');
       return null;
 
   }
 }
-lang_Parser.prototype.declaration = function() {
+Parser.prototype.declaration = function() {
   var start = this._peekToken.start;
   if (this._peekKind(74/*TokenKind.FACTORY*/)) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
   return this.finishDefinition(start, modifiers, this.declaredIdentifier(true));
 }
-lang_Parser.prototype.factoryConstructorDeclaration = function() {
+Parser.prototype.factoryConstructorDeclaration = function() {
   var start = this._peekToken.start;
   var factoryToken = this._lang_next();
   var names = [this.identifier()];
   while (this._maybeEat(14/*TokenKind.DOT*/)) {
     names.add(this.identifier());
   }
   var typeParams = null;
   if (this._peekKind(52/*TokenKind.LT*/)) {
     typeParams = this.typeParameters();
   }
   var name = null;
   var type = null;
   if (this._maybeEat(14/*TokenKind.DOT*/)) {
     name = this.identifier();
   }
   else if (typeParams == null) {
     if (names.length > 1) {
       name = names.removeLast();
     }
     else {
-      name = new lang_Identifier('', names.$index(0).get$span());
+      name = new Identifier('', names.$index(0).get$span());
     }
   }
   else {
-    name = new lang_Identifier('', names.$index(0).get$span());
+    name = new Identifier('', names.$index(0).get$span());
   }
   if (names.length > 1) {
     this._lang_error('unsupported qualified name for factory', names.$index(0).get$span());
   }
   type = new NameTypeReference(false, names.$index(0), null, names.$index(0).get$span());
   var di = new DeclaredIdentifier(type, name, this._makeSpan(start));
   return this.finishDefinition(start, [factoryToken], di);
 }
-lang_Parser.prototype.statement = function() {
+Parser.prototype.statement = function() {
   switch (this._peek()) {
     case 87/*TokenKind.BREAK*/:
 
       return this.breakStatement();
+      $throw(new FallThroughError("./parser.dart", 379))
 
     case 91/*TokenKind.CONTINUE*/:
 
       return this.continueStatement();
+      $throw(new FallThroughError("./parser.dart", 381))
 
     case 104/*TokenKind.RETURN*/:
 
       return this.returnStatement();
+      $throw(new FallThroughError("./parser.dart", 383))
 
     case 108/*TokenKind.THROW*/:
 
       return this.throwStatement();
+      $throw(new FallThroughError("./parser.dart", 385))
 
     case 71/*TokenKind.ASSERT*/:
 
       return this.assertStatement();
+      $throw(new FallThroughError("./parser.dart", 387))
 
     case 113/*TokenKind.WHILE*/:
 
       return this.whileStatement();
+      $throw(new FallThroughError("./parser.dart", 390))
 
     case 93/*TokenKind.DO*/:
 
       return this.doStatement();
+      $throw(new FallThroughError("./parser.dart", 392))
 
     case 98/*TokenKind.FOR*/:
 
       return this.forStatement();
+      $throw(new FallThroughError("./parser.dart", 394))
 
     case 99/*TokenKind.IF*/:
 
       return this.ifStatement();
+      $throw(new FallThroughError("./parser.dart", 397))
 
     case 106/*TokenKind.SWITCH*/:
 
       return this.switchStatement();
+      $throw(new FallThroughError("./parser.dart", 399))
 
     case 110/*TokenKind.TRY*/:
 
       return this.tryStatement();
+      $throw(new FallThroughError("./parser.dart", 402))
 
     case 6/*TokenKind.LBRACE*/:
 
       return this.block();
+      $throw(new FallThroughError("./parser.dart", 405))
 
     case 10/*TokenKind.SEMICOLON*/:
 
       return this.emptyStatement();
+      $throw(new FallThroughError("./parser.dart", 407))
 
     case 96/*TokenKind.FINAL*/:
 
       return this.declaration();
+      $throw(new FallThroughError("./parser.dart", 410))
 
     case 111/*TokenKind.VAR*/:
 
       return this.declaration();
+      $throw(new FallThroughError("./parser.dart", 412))
 
     default:
 
       return this.finishExpressionAsStatement(this.expression());
 
   }
 }
-lang_Parser.prototype.finishExpressionAsStatement = function(expr) {
+Parser.prototype.finishExpressionAsStatement = function(expr) {
   var start = expr.get$span().start;
   if (this._maybeEat(8/*TokenKind.COLON*/)) {
     var label = this._makeLabel(expr);
     return new LabeledStatement(label, this.statement(), this._makeSpan(start));
   }
   if ((expr instanceof LambdaExpression)) {
     if (!(expr.func.body instanceof BlockStatement)) {
       this._eatSemicolon();
       expr.func.span = this._makeSpan(start);
     }
@@ skipping 16 matching lines @@
     var gt = this._finishTypeArguments(baseType, 0, typeArgs);
     var name = this.identifier();
     var value = null;
     if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
       value = this.expression();
     }
     return this.finishField(expr.get$span().start, null, gt, name, value);
   }
   else {
     this._eatSemicolon();
-    return new lang_ExpressionStatement(expr, this._makeSpan(expr.get$span().start));
+    return new ExpressionStatement(expr, this._makeSpan(expr.get$span().start));
   }
 }
-lang_Parser.prototype.testCondition = function() {
+Parser.prototype.testCondition = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var ret = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   return ret;
 }
-lang_Parser.prototype.block = function() {
+Parser.prototype.block = function() {
   var start = this._peekToken.start;
   this._eat(6/*TokenKind.LBRACE*/);
   var stmts = [];
   while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
     if (this.isPrematureEndOfFile()) break;
     stmts.add(this.statement());
   }
   return new BlockStatement(stmts, this._makeSpan(start));
 }
-lang_Parser.prototype.emptyStatement = function() {
+Parser.prototype.emptyStatement = function() {
   var start = this._peekToken.start;
   this._eat(10/*TokenKind.SEMICOLON*/);
   return new EmptyStatement(this._makeSpan(start));
 }
-lang_Parser.prototype.ifStatement = function() {
+Parser.prototype.ifStatement = function() {
   var start = this._peekToken.start;
   this._eat(99/*TokenKind.IF*/);
   var test = this.testCondition();
   var trueBranch = this.statement();
   var falseBranch = null;
   if (this._maybeEat(94/*TokenKind.ELSE*/)) {
     falseBranch = this.statement();
   }
   return new IfStatement(test, trueBranch, falseBranch, this._makeSpan(start));
 }
-lang_Parser.prototype.whileStatement = function() {
+Parser.prototype.whileStatement = function() {
   var start = this._peekToken.start;
   this._eat(113/*TokenKind.WHILE*/);
   var test = this.testCondition();
   var body = this.statement();
   return new WhileStatement(test, body, this._makeSpan(start));
 }
-lang_Parser.prototype.doStatement = function() {
+Parser.prototype.doStatement = function() {
   var start = this._peekToken.start;
   this._eat(93/*TokenKind.DO*/);
   var body = this.statement();
   this._eat(113/*TokenKind.WHILE*/);
   var test = this.testCondition();
   this._eatSemicolon();
   return new DoStatement(body, test, this._makeSpan(start));
 }
-lang_Parser.prototype.forStatement = function() {
+Parser.prototype.forStatement = function() {
   var start = this._peekToken.start;
   this._eat(98/*TokenKind.FOR*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var init = this.forInitializerStatement(start);
   if ((init instanceof ForInStatement)) {
     return init;
   }
   var test = null;
   if (!this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
     test = this.expression();
     this._eatSemicolon();
   }
   var step = [];
   if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
     step.add(this.expression());
     while (this._maybeEat(11/*TokenKind.COMMA*/)) {
       step.add(this.expression());
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   var body = this.statement();
   return new ForStatement(init, test, step, body, this._makeSpan(start));
 }
-lang_Parser.prototype.forInitializerStatement = function(start) {
+Parser.prototype.forInitializerStatement = function(start) {
   if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
     return null;
   }
   else {
     var init = this.expression();
     if (this._peekKind(11/*TokenKind.COMMA*/) && this._isBin(init, 52/*TokenKind.LT*/)) {
       this._eat(11/*TokenKind.COMMA*/);
       var baseType = this._makeType(init.x);
       var typeArgs = [this._makeType(init.y)];
       var gt = this._finishTypeArguments(baseType, 0, typeArgs);
       var name = this.identifier();
       init = new DeclaredIdentifier(gt, name, this._makeSpan(init.get$span().start));
     }
     if (this._maybeEat(100/*TokenKind.IN*/)) {
       return this._finishForIn(start, this._makeDeclaredIdentifier(init));
     }
     else {
       return this.finishExpressionAsStatement(init);
     }
   }
 }
-lang_Parser.prototype._finishForIn = function(start, di) {
+Parser.prototype._finishForIn = function(start, di) {
   var expr = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   var body = this.statement();
   return new ForInStatement(di, expr, body, this._makeSpan(start));
 }
-lang_Parser.prototype.tryStatement = function() {
+Parser.prototype.tryStatement = function() {
   var start = this._peekToken.start;
   this._eat(110/*TokenKind.TRY*/);
   var body = this.block();
   var catches = [];
   while (this._peekKind(89/*TokenKind.CATCH*/)) {
     catches.add(this.catchNode());
   }
   var finallyBlock = null;
   if (this._maybeEat(97/*TokenKind.FINALLY*/)) {
     finallyBlock = this.block();
   }
   return new TryStatement(body, catches, finallyBlock, this._makeSpan(start));
 }
-lang_Parser.prototype.catchNode = function() {
+Parser.prototype.catchNode = function() {
   var start = this._peekToken.start;
   this._eat(89/*TokenKind.CATCH*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var exc = this.declaredIdentifier(false);
   var trace = null;
   if (this._maybeEat(11/*TokenKind.COMMA*/)) {
     trace = this.declaredIdentifier(false);
   }
   this._eat(3/*TokenKind.RPAREN*/);
   var body = this.block();
   return new CatchNode(exc, trace, body, this._makeSpan(start));
 }
-lang_Parser.prototype.switchStatement = function() {
+Parser.prototype.switchStatement = function() {
   var start = this._peekToken.start;
   this._eat(106/*TokenKind.SWITCH*/);
   var test = this.testCondition();
   var cases = [];
   this._eat(6/*TokenKind.LBRACE*/);
   while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
     cases.add(this.caseNode());
   }
   return new SwitchStatement(test, cases, this._makeSpan(start));
 }
-lang_Parser.prototype._peekCaseEnd = function() {
+Parser.prototype._peekCaseEnd = function() {
   var kind = this._peek();
   return $eq(kind, 7/*TokenKind.RBRACE*/) || $eq(kind, 88/*TokenKind.CASE*/) || $eq(kind, 92/*TokenKind.DEFAULT*/);
 }
-lang_Parser.prototype.caseNode = function() {
+Parser.prototype.caseNode = function() {
   var start = this._peekToken.start;
   var label = null;
   if (this._peekIdentifier()) {
     this._eat(8/*TokenKind.COLON*/);
     label = this.identifier();
   }
   var cases = [];
   while (true) {
     if (this._maybeEat(88/*TokenKind.CASE*/)) {
       cases.add(this.expression());
@@ skipping 10 matching lines @@
   if (cases.length == 0) {
     this._lang_error('case or default');
   }
   var stmts = [];
   while (!this._peekCaseEnd()) {
     if (this.isPrematureEndOfFile()) break;
     stmts.add(this.statement());
   }
   return new CaseNode(label, cases, stmts, this._makeSpan(start));
 }
-lang_Parser.prototype.returnStatement = function() {
+Parser.prototype.returnStatement = function() {
   var start = this._peekToken.start;
   this._eat(104/*TokenKind.RETURN*/);
   var expr;
   if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
     expr = null;
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ReturnStatement(expr, this._makeSpan(start));
 }
-lang_Parser.prototype.throwStatement = function() {
+Parser.prototype.throwStatement = function() {
   var start = this._peekToken.start;
   this._eat(108/*TokenKind.THROW*/);
   var expr;
   if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
     expr = null;
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ThrowStatement(expr, this._makeSpan(start));
 }
-lang_Parser.prototype.assertStatement = function() {
+Parser.prototype.assertStatement = function() {
   var start = this._peekToken.start;
   this._eat(71/*TokenKind.ASSERT*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var expr = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   this._eatSemicolon();
   return new AssertStatement(expr, this._makeSpan(start));
 }
-lang_Parser.prototype.breakStatement = function() {
+Parser.prototype.breakStatement = function() {
   var start = this._peekToken.start;
   this._eat(87/*TokenKind.BREAK*/);
   var name = null;
   if (this._peekIdentifier()) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new BreakStatement(name, this._makeSpan(start));
 }
-lang_Parser.prototype.continueStatement = function() {
+Parser.prototype.continueStatement = function() {
   var start = this._peekToken.start;
   this._eat(91/*TokenKind.CONTINUE*/);
   var name = null;
   if (this._peekIdentifier()) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new ContinueStatement(name, this._makeSpan(start));
 }
-lang_Parser.prototype.expression = function() {
+Parser.prototype.expression = function() {
   return this.infixExpression(0);
 }
-lang_Parser.prototype._makeType = function(expr) {
+Parser.prototype._makeType = function(expr) {
   if ((expr instanceof VarExpression)) {
     return new NameTypeReference(false, expr.get$name(), null, expr.get$span());
   }
   else if ((expr instanceof DotExpression)) {
     var type = this._makeType(expr.self);
     if (type.names == null) {
       type.names = [expr.get$name()];
     }
     else {
       type.names.add(expr.get$name());
     }
     type.span = expr.get$span();
     return type;
   }
   else {
     this._lang_error('expected type reference');
     return null;
   }
 }
-lang_Parser.prototype.infixExpression = function(precedence) {
+Parser.prototype.infixExpression = function(precedence) {
   return this.finishInfixExpression(this.unaryExpression(), precedence);
 }
-lang_Parser.prototype._finishDeclaredId = function(type) {
+Parser.prototype._finishDeclaredId = function(type) {
   var name = this.identifier();
   return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan(type.get$span().start)));
 }
-lang_Parser.prototype._fixAsType = function(x) {
+Parser.prototype._fixAsType = function(x) {
   if (this._maybeEat(53/*TokenKind.GT*/)) {
     var base = this._makeType(x.x);
     var typeParam = this._makeType(x.y);
     var type = new GenericTypeReference(base, [typeParam], 0, this._makeSpan(x.span.start));
     return this._finishDeclaredId(type);
   }
   else {
     var base = this._makeType(x.x);
     var paramBase = this._makeType(x.y);
     var firstParam = this.addTypeArguments(paramBase, 1);
     var type;
     if (firstParam.depth <= 0) {
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     else if (this._maybeEat(11/*TokenKind.COMMA*/)) {
       type = this._finishTypeArguments(base, 0, [firstParam]);
     }
     else {
       this._eat(53/*TokenKind.GT*/);
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     return this._finishDeclaredId(type);
   }
 }
-lang_Parser.prototype.finishInfixExpression = function(x, precedence) {
+Parser.prototype.finishInfixExpression = function(x, precedence) {
   while (true) {
     var kind = this._peek();
     var prec = TokenKind.infixPrecedence(this._peek());
     if (prec >= precedence) {
       if (kind == 52/*TokenKind.LT*/ || kind == 53/*TokenKind.GT*/) {
         if (this._isBin(x, 52/*TokenKind.LT*/)) {
           return this._fixAsType(x);
         }
       }
       var op = this._lang_next();
@@ skipping 12 matching lines @@
       else {
         x = new BinaryExpression(op, x, y, this._makeSpan(x.span.start));
       }
     }
     else {
       break;
     }
   }
   return x;
 }
-lang_Parser.prototype._isPrefixUnaryOperator = function(kind) {
+Parser.prototype._isPrefixUnaryOperator = function(kind) {
   switch (kind) {
     case 42/*TokenKind.ADD*/:
     case 43/*TokenKind.SUB*/:
     case 19/*TokenKind.NOT*/:
     case 18/*TokenKind.BIT_NOT*/:
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
       return true;
+      $throw(new FallThroughError("./parser.dart", 835))
 
     default:
 
       return false;
 
   }
 }
-lang_Parser.prototype.unaryExpression = function() {
+Parser.prototype.unaryExpression = function() {
   var start = this._peekToken.start;
   if (this._isPrefixUnaryOperator(this._peek())) {
     var tok = this._lang_next();
     var expr = this.unaryExpression();
     return new UnaryExpression(tok, expr, this._makeSpan(start));
   }
   return this.finishPostfixExpression(this.primary());
 }
-lang_Parser.prototype.argument = function() {
+Parser.prototype.argument = function() {
   var start = this._peekToken.start;
   var expr;
   var label = null;
   if (this._maybeEat(15/*TokenKind.ELLIPSIS*/)) {
-    label = new lang_Identifier('...', this._makeSpan(start));
+    label = new Identifier('...', this._makeSpan(start));
   }
   expr = this.expression();
   if (label == null && this._maybeEat(8/*TokenKind.COLON*/)) {
     label = this._makeLabel(expr);
     expr = this.expression();
   }
   return new ArgumentNode(label, expr, this._makeSpan(start));
 }
-lang_Parser.prototype.arguments = function() {
+Parser.prototype.arguments = function() {
   var args = [];
   this._eat(2/*TokenKind.LPAREN*/);
   if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
     do {
       args.add(this.argument());
     }
     while (this._maybeEat(11/*TokenKind.COMMA*/))
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return args;
 }
-lang_Parser.prototype.get$arguments = function() {
-  return lang_Parser.prototype.arguments.bind(this);
+Parser.prototype.get$arguments = function() {
+  return Parser.prototype.arguments.bind(this);
 }
-lang_Parser.prototype.finishPostfixExpression = function(expr) {
+Parser.prototype.finishPostfixExpression = function(expr) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       return this.finishPostfixExpression(new CallExpression(expr, this.arguments(), this._makeSpan(expr.get$span().start)));
+      $throw(new FallThroughError("./parser.dart", 884))
 
     case 4/*TokenKind.LBRACK*/:
 
       this._eat(4/*TokenKind.LBRACK*/);
       var index = this.expression();
       this._eat(5/*TokenKind.RBRACK*/);
       return this.finishPostfixExpression(new IndexExpression(expr, index, this._makeSpan(expr.get$span().start)));
+      $throw(new FallThroughError("./parser.dart", 890))
 
     case 14/*TokenKind.DOT*/:
 
       this._eat(14/*TokenKind.DOT*/);
       var name = this.identifier();
       var ret = new DotExpression(expr, name, this._makeSpan(expr.get$span().start));
       return this.finishPostfixExpression(ret);
+      $throw(new FallThroughError("./parser.dart", 896))
 
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
       var tok = this._lang_next();
       return new PostfixExpression(expr, tok, this._makeSpan(expr.get$span().start));
+      $throw(new FallThroughError("./parser.dart", 901))
 
     case 9/*TokenKind.ARROW*/:
     case 6/*TokenKind.LBRACE*/:
 
       if (this._inInitializers) return expr;
       var body = this.functionBody(true);
       return this._makeFunction(expr, body);
+      $throw(new FallThroughError("./parser.dart", 909))
 
     default:
 
       if (this._peekIdentifier()) {
         return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan(expr.get$span().start)));
       }
       else {
         return expr;
       }
 
   }
 }
-lang_Parser.prototype._isBin = function(expr, kind) {
+Parser.prototype._isBin = function(expr, kind) {
   return (expr instanceof BinaryExpression) && expr.op.kind == kind;
 }
-lang_Parser.prototype._boolTypeRef = function(span) {
+Parser.prototype._boolTypeRef = function(span) {
   return new TypeReference(span, world.boolType);
 }
-lang_Parser.prototype._numTypeRef = function(span) {
+Parser.prototype._numTypeRef = function(span) {
   return new TypeReference(span, world.numType);
 }
-lang_Parser.prototype._stringTypeRef = function(span) {
+Parser.prototype._stringTypeRef = function(span) {
   return new TypeReference(span, world.stringType);
 }
-lang_Parser.prototype.primary = function() {
+Parser.prototype.primary = function() {
   var start = this._peekToken.start;
   switch (this._peek()) {
     case 107/*TokenKind.THIS*/:
 
       this._eat(107/*TokenKind.THIS*/);
       return new ThisExpression(this._makeSpan(start));
+      $throw(new FallThroughError("./parser.dart", 944))
 
     case 105/*TokenKind.SUPER*/:
 
       this._eat(105/*TokenKind.SUPER*/);
       return new SuperExpression(this._makeSpan(start));
+      $throw(new FallThroughError("./parser.dart", 948))
 
     case 90/*TokenKind.CONST*/:
 
       this._eat(90/*TokenKind.CONST*/);
       if (this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/)) {
         return this.finishListLiteral(start, true, null);
       }
       else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
         return this.finishMapLiteral(start, true, null);
       }
       else if (this._peekKind(52/*TokenKind.LT*/)) {
         return this.finishTypedLiteral(start, true);
       }
       else {
         return this.finishNewExpression(start, true);
       }
+      $throw(new FallThroughError("./parser.dart", 952))
 
     case 102/*TokenKind.NEW*/:
 
       this._eat(102/*TokenKind.NEW*/);
       return this.finishNewExpression(start, false);
+      $throw(new FallThroughError("./parser.dart", 964))
 
     case 2/*TokenKind.LPAREN*/:
 
       return this._parenOrLambda();
+      $throw(new FallThroughError("./parser.dart", 967))
 
     case 4/*TokenKind.LBRACK*/:
     case 56/*TokenKind.INDEX*/:
 
       return this.finishListLiteral(start, false, null);
+      $throw(new FallThroughError("./parser.dart", 971))
 
     case 6/*TokenKind.LBRACE*/:
 
       return this.finishMapLiteral(start, false, null);
+      $throw(new FallThroughError("./parser.dart", 973))
 
     case 103/*TokenKind.NULL*/:
 
       this._eat(103/*TokenKind.NULL*/);
       return new NullExpression(this._makeSpan(start));
+      $throw(new FallThroughError("./parser.dart", 978))
 
     case 109/*TokenKind.TRUE*/:
 
       this._eat(109/*TokenKind.TRUE*/);
       return new LiteralExpression(true, this._boolTypeRef(this._makeSpan(start)), 'true', this._makeSpan(start));
+      $throw(new FallThroughError("./parser.dart", 983))
 
     case 95/*TokenKind.FALSE*/:
 
       this._eat(95/*TokenKind.FALSE*/);
       return new LiteralExpression(false, this._boolTypeRef(this._makeSpan(start)), 'false', this._makeSpan(start));
+      $throw(new FallThroughError("./parser.dart", 988))
 
     case 61/*TokenKind.HEX_NUMBER*/:
 
       var t = this._lang_next();
-      return new LiteralExpression(lang_Parser.parseHex(t.get$text().substring(2)), this._numTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+      return new LiteralExpression(Parser.parseHex(t.get$text().substring(2)), this._numTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+      $throw(new FallThroughError("./parser.dart", 994))
 
     case 60/*TokenKind.NUMBER*/:
 
       var t = this._lang_next();
       return new LiteralExpression(Math.parseDouble(t.get$text()), this._numTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+      $throw(new FallThroughError("./parser.dart", 999))
 
     case 58/*TokenKind.STRING*/:
 
       return this.stringLiteralExpr();
+      $throw(new FallThroughError("./parser.dart", 1003))
 
     case 65/*TokenKind.INCOMPLETE_STRING*/:
 
       return this.stringInterpolation();
+      $throw(new FallThroughError("./parser.dart", 1006))
 
     case 52/*TokenKind.LT*/:
 
       return this.finishTypedLiteral(start, false);
+      $throw(new FallThroughError("./parser.dart", 1009))
 
     case 112/*TokenKind.VOID*/:
     case 111/*TokenKind.VAR*/:
     case 96/*TokenKind.FINAL*/:
 
       return this.declaredIdentifier(false);
+      $throw(new FallThroughError("./parser.dart", 1014))
 
     default:
 
       if (!this._peekIdentifier()) {
         this._errorExpected('expression');
       }
       return new VarExpression(this.identifier(), this._makeSpan(start));
 
   }
 }
-lang_Parser.prototype.stringInterpolation = function() {
+Parser.prototype.stringInterpolation = function() {
   var start = this._peekToken.start;
   var lits = [];
   var startQuote = null, endQuote = null;
   while (this._peekKind(65/*TokenKind.INCOMPLETE_STRING*/)) {
     var token = this._lang_next();
     var text = token.get$text();
     if (startQuote == null) {
       if (isMultilineString(text)) {
         endQuote = text.substring(0, 3);
         startQuote = endQuote + '\n';
@@ skipping 18 matching lines @@
   }
   var tok = this._lang_next();
   if (tok.kind != 58/*TokenKind.STRING*/) {
     this._errorExpected('interpolated string');
   }
   var text = startQuote + tok.get$text();
   lits.add(this.makeStringLiteral(text, tok.get$span()));
   var span = this._makeSpan(start);
   return new LiteralExpression(lits, this._stringTypeRef(span), '\$\$\$', span);
 }
-lang_Parser.prototype.makeStringLiteral = function(text, span) {
+Parser.prototype.makeStringLiteral = function(text, span) {
   return new LiteralExpression(text, this._stringTypeRef(span), text, span);
 }
-lang_Parser.prototype.stringLiteralExpr = function() {
+Parser.prototype.stringLiteralExpr = function() {
   var token = this._lang_next();
   return this.makeStringLiteral(token.get$text(), token.get$span());
 }
-lang_Parser.prototype.maybeStringLiteral = function() {
+Parser.prototype.maybeStringLiteral = function() {
   var kind = this._peek();
   if ($eq(kind, 58/*TokenKind.STRING*/)) {
     return parseStringLiteral(this._lang_next().get$text());
   }
   else if ($eq(kind, 59/*TokenKind.STRING_PART*/)) {
     this._lang_next();
     this._errorExpected('string literal, but found interpolated string start');
   }
   else if ($eq(kind, 65/*TokenKind.INCOMPLETE_STRING*/)) {
     this._lang_next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
-lang_Parser.prototype._parenOrLambda = function() {
+Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
   var args = this.arguments();
   if (!this._inInitializers && (this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/))) {
     var body = this.functionBody(true);
     var formals = this._makeFormals(args);
     var func = new FunctionDefinition(null, null, null, formals, null, body, this._makeSpan(start));
     return new LambdaExpression(func, func.get$span());
   }
   else {
     if (args.length == 1) {
       return new ParenExpression(args.$index(0).get$value(), this._makeSpan(start));
     }
     else {
       this._lang_error('unexpected comma expression');
       return args.$index(0).get$value();
     }
   }
 }
-lang_Parser.prototype._typeAsIdentifier = function(type) {
+Parser.prototype._typeAsIdentifier = function(type) {
   return type.get$name();
 }
-lang_Parser.prototype._specialIdentifier = function(includeOperators) {
+Parser.prototype._specialIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var name;
   switch (this._peek()) {
     case 15/*TokenKind.ELLIPSIS*/:
 
       this._eat(15/*TokenKind.ELLIPSIS*/);
       this._lang_error('rest no longer supported', this._previousToken);
       name = this.identifier().get$name();
       break;
+      $throw(new FallThroughError("./parser.dart", 1123))
 
     case 107/*TokenKind.THIS*/:
 
       this._eat(107/*TokenKind.THIS*/);
       this._eat(14/*TokenKind.DOT*/);
       name = ('this.' + this.identifier().get$name() + '');
       break;
+      $throw(new FallThroughError("./parser.dart", 1128))
 
     case 75/*TokenKind.GET*/:
 
       if (!includeOperators) return null;
       this._eat(75/*TokenKind.GET*/);
       name = ('get\$' + this.identifier().get$name() + '');
       break;
+      $throw(new FallThroughError("./parser.dart", 1133))
 
     case 83/*TokenKind.SET*/:
 
       if (!includeOperators) return null;
       this._eat(83/*TokenKind.SET*/);
       name = ('set\$' + this.identifier().get$name() + '');
       break;
+      $throw(new FallThroughError("./parser.dart", 1138))
 
     case 82/*TokenKind.OPERATOR*/:
 
       if (!includeOperators) return null;
       this._eat(82/*TokenKind.OPERATOR*/);
       var tok = this._lang_next();
       if (tok.kind == 81/*TokenKind.NEGATE*/) {
         name = '\$negate';
       }
       else {
         name = TokenKind.binaryMethodName(tok.kind);
         if (name == null) {
           this._errorExpected(('legal operator name, but found: ' + tok + ''));
           name = tok.toString();
         }
       }
       break;
+      $throw(new FallThroughError("./parser.dart", 1152))
 
     default:
 
       return null;
 
   }
-  return new lang_Identifier(name, this._makeSpan(start));
+  return new Identifier(name, this._makeSpan(start));
 }
-lang_Parser.prototype.declaredIdentifier = function(includeOperators) {
+Parser.prototype.declaredIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var myType = null;
   var name = this._specialIdentifier(includeOperators);
   if (name == null) {
     myType = this.type(0);
     name = this._specialIdentifier(includeOperators);
     if (name == null) {
       if (this._peekIdentifier()) {
         name = this.identifier();
       }
       else if ((myType instanceof NameTypeReference) && myType.names == null) {
         name = this._typeAsIdentifier(myType);
         myType = null;
       }
       else {
       }
     }
   }
   return new DeclaredIdentifier(myType, name, this._makeSpan(start));
 }
-lang_Parser._hexDigit = function(c) {
+Parser._hexDigit = function(c) {
   if (c >= 48 && c <= 57) {
     return c - 48;
   }
   else if (c >= 97 && c <= 102) {
     return c - 87;
   }
   else if (c >= 65 && c <= 70) {
     return c - 55;
   }
   else {
-    return -1;
+    return -1.000000/*-1*/;
   }
 }
-lang_Parser.parseHex = function(hex) {
+Parser.parseHex = function(hex) {
   var result = 0;
   for (var i = 0;
    i < hex.length; i++) {
-    var digit = lang_Parser._hexDigit(hex.charCodeAt(i));
+    var digit = Parser._hexDigit(hex.charCodeAt(i));
     result = (result << 4) + digit;
   }
   return result;
 }
-lang_Parser.prototype.finishNewExpression = function(start, isConst) {
+Parser.prototype.finishNewExpression = function(start, isConst) {
   var type = this.type(0);
   var name = null;
   if (this._maybeEat(14/*TokenKind.DOT*/)) {
     name = this.identifier();
   }
   var args = this.arguments();
-  return new lang_NewExpression(isConst, type, name, args, this._makeSpan(start));
+  return new NewExpression(isConst, type, name, args, this._makeSpan(start));
 }
-lang_Parser.prototype.finishListLiteral = function(start, isConst, type) {
+Parser.prototype.finishListLiteral = function(start, isConst, type) {
   if (this._maybeEat(56/*TokenKind.INDEX*/)) {
     return new ListExpression(isConst, type, [], this._makeSpan(start));
   }
   var values = [];
   this._eat(4/*TokenKind.LBRACK*/);
   while (!this._maybeEat(5/*TokenKind.RBRACK*/)) {
     if (this.isPrematureEndOfFile()) break;
     values.add(this.expression());
     if (!this._maybeEat(11/*TokenKind.COMMA*/)) {
       this._eat(5/*TokenKind.RBRACK*/);
       break;
     }
   }
   return new ListExpression(isConst, type, values, this._makeSpan(start));
 }
-lang_Parser.prototype.finishMapLiteral = function(start, isConst, type) {
+Parser.prototype.finishMapLiteral = function(start, isConst, type) {
   var items = [];
   this._eat(6/*TokenKind.LBRACE*/);
   while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
     if (this.isPrematureEndOfFile()) break;
     items.add(this.expression());
     this._eat(8/*TokenKind.COLON*/);
     items.add(this.expression());
     if (!this._maybeEat(11/*TokenKind.COMMA*/)) {
       this._eat(7/*TokenKind.RBRACE*/);
       break;
     }
   }
   return new MapExpression(isConst, type, items, this._makeSpan(start));
 }
-lang_Parser.prototype.finishTypedLiteral = function(start, isConst) {
+Parser.prototype.finishTypedLiteral = function(start, isConst) {
   var span = this._makeSpan(start);
   var typeToBeNamedLater = new NameTypeReference(false, null, null, span);
   var genericType = this.addTypeArguments(typeToBeNamedLater, 0);
   if (this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/)) {
     return this.finishListLiteral(start, isConst, genericType);
   }
   else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
     return this.finishMapLiteral(start, isConst, genericType);
   }
   else {
     this._errorExpected('array or map literal');
   }
 }
-lang_Parser.prototype._readModifiers = function() {
+Parser.prototype._readModifiers = function() {
   var modifiers = null;
   while (true) {
     switch (this._peek()) {
       case 85/*TokenKind.STATIC*/:
       case 96/*TokenKind.FINAL*/:
       case 90/*TokenKind.CONST*/:
       case 70/*TokenKind.ABSTRACT*/:
       case 74/*TokenKind.FACTORY*/:
 
         if (modifiers == null) modifiers = [];
         modifiers.add(this._lang_next());
         break;
+        $throw(new FallThroughError("./parser.dart", 1281))
 
       default:
 
         return modifiers;
 
     }
   }
   return null;
 }
-lang_Parser.prototype.typeParameter = function() {
+Parser.prototype.typeParameter = function() {
   var start = this._peekToken.start;
   var name = this.identifier();
   var myType = null;
   if (this._maybeEat(73/*TokenKind.EXTENDS*/)) {
     myType = this.type(1);
   }
   return new TypeParameter(name, myType, this._makeSpan(start));
 }
-lang_Parser.prototype.typeParameters = function() {
+Parser.prototype.typeParameters = function() {
   this._eat(52/*TokenKind.LT*/);
   var closed = false;
   var ret = [];
   do {
     var tp = this.typeParameter();
     ret.add(tp);
     if ((tp.extendsType instanceof GenericTypeReference) && tp.extendsType.depth == 0) {
       closed = true;
       break;
     }
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   if (!closed) {
     this._eat(53/*TokenKind.GT*/);
   }
   return ret;
 }
-lang_Parser.prototype.get$typeParameters = function() {
-  return lang_Parser.prototype.typeParameters.bind(this);
+Parser.prototype.get$typeParameters = function() {
+  return Parser.prototype.typeParameters.bind(this);
 }
-lang_Parser.prototype._eatClosingAngle = function(depth) {
+Parser.prototype._eatClosingAngle = function(depth) {
   if (this._maybeEat(53/*TokenKind.GT*/)) {
     return depth;
   }
   else if (depth > 0 && this._maybeEat(40/*TokenKind.SAR*/)) {
     return depth - 1;
   }
   else if (depth > 1 && this._maybeEat(41/*TokenKind.SHR*/)) {
     return depth - 2;
   }
   else {
     this._errorExpected('>');
     return depth;
   }
 }
-lang_Parser.prototype.addTypeArguments = function(baseType, depth) {
+Parser.prototype.addTypeArguments = function(baseType, depth) {
   this._eat(52/*TokenKind.LT*/);
   return this._finishTypeArguments(baseType, depth, []);
 }
-lang_Parser.prototype._finishTypeArguments = function(baseType, depth, types) {
-  var delta = -1;
+Parser.prototype._finishTypeArguments = function(baseType, depth, types) {
+  var delta = -1.000000/*-1*/;
   do {
     var myType = this.type(depth + 1);
     types.add(myType);
     if ((myType instanceof GenericTypeReference) && myType.depth <= depth) {
       delta = depth - myType.depth;
       break;
     }
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   if (delta >= 0) {
     depth = depth - delta;
   }
   else {
     depth = this._eatClosingAngle(depth);
   }
   var span = this._makeSpan(baseType.span.start);
   return new GenericTypeReference(baseType, types, depth, span);
 }
-lang_Parser.prototype.typeList = function() {
+Parser.prototype.typeList = function() {
   var types = [];
   do {
     types.add(this.type(0));
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   return types;
 }
-lang_Parser.prototype.type = function(depth) {
+Parser.prototype.type = function(depth) {
   var start = this._peekToken.start;
   var name;
   var names = null;
   var typeArgs = null;
   var isFinal = false;
   switch (this._peek()) {
     case 112/*TokenKind.VOID*/:
 
       return new TypeReference(this._lang_next().get$span(), world.voidType);
+      $throw(new FallThroughError("./parser.dart", 1379))
 
     case 111/*TokenKind.VAR*/:
 
       return new TypeReference(this._lang_next().get$span(), world.varType);
+      $throw(new FallThroughError("./parser.dart", 1381))
 
     case 96/*TokenKind.FINAL*/:
 
       this._eat(96/*TokenKind.FINAL*/);
       isFinal = true;
       name = this.identifier();
       break;
+      $throw(new FallThroughError("./parser.dart", 1386))
 
     default:
 
       name = this.identifier();
       break;
 
   }
   while (this._maybeEat(14/*TokenKind.DOT*/)) {
     if (names == null) names = [];
     names.add(this.identifier());
   }
   var typeRef = new NameTypeReference(isFinal, name, names, this._makeSpan(start));
   if (this._peekKind(52/*TokenKind.LT*/)) {
     return this.addTypeArguments(typeRef, depth);
   }
   else {
     return typeRef;
   }
 }
-lang_Parser.prototype.formalParameter = function(inOptionalBlock) {
+Parser.prototype.formalParameter = function(inOptionalBlock) {
   var start = this._peekToken.start;
   var isThis = false;
   var isRest = false;
   var di = this.declaredIdentifier(false);
   var type = di.type;
   var name = di.get$name();
   var value = null;
   if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
     if (!inOptionalBlock) {
       this._lang_error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
   else if (this._peekKind(2/*TokenKind.LPAREN*/)) {
     var formals = this.formalParameterList();
     var func = new FunctionDefinition(null, type, name, formals, null, null, this._makeSpan(start));
     type = new FunctionTypeReference(false, func, func.get$span());
   }
   if (inOptionalBlock && value == null) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
 }
-lang_Parser.prototype.formalParameterList = function() {
+Parser.prototype.formalParameterList = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var formals = [];
   var inOptionalBlock = false;
   if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
     if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
       inOptionalBlock = true;
     }
     formals.add(this.formalParameter(inOptionalBlock));
     while (this._maybeEat(11/*TokenKind.COMMA*/)) {
       if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
         if (inOptionalBlock) {
           this._lang_error('already inside an optional block', this._previousToken.get$span());
         }
         inOptionalBlock = true;
       }
       formals.add(this.formalParameter(inOptionalBlock));
     }
     if (inOptionalBlock) {
       this._eat(5/*TokenKind.RBRACK*/);
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return formals;
 }
-lang_Parser.prototype.identifier = function() {
+Parser.prototype.identifier = function() {
   var tok = this._lang_next();
   if (!TokenKind.isIdentifier(tok.kind)) {
     this._lang_error(('expected identifier, but found ' + tok + ''), tok.get$span());
   }
-  return new lang_Identifier(tok.get$text(), this._makeSpan(tok.start));
+  return new Identifier(tok.get$text(), this._makeSpan(tok.start));
 }
-lang_Parser.prototype._makeFunction = function(expr, body) {
+Parser.prototype._makeFunction = function(expr, body) {
   var name, type;
   if ((expr instanceof CallExpression)) {
     if ((expr.target instanceof VarExpression)) {
       name = expr.target.get$name();
       type = null;
     }
     else if ((expr.target instanceof DeclaredIdentifier)) {
       name = expr.target.get$name();
       type = expr.target.type;
     }
     else {
       this._lang_error('bad function');
     }
     var formals = this._makeFormals(expr.get$arguments());
     var span = new SourceSpan(expr.get$span().file, expr.get$span().start, body.get$span().end);
     var func = new FunctionDefinition(null, type, name, formals, null, body, span);
     return new LambdaExpression(func, func.get$span());
   }
   else {
     this._lang_error('expected function');
   }
 }
-lang_Parser.prototype._makeFormal = function(expr) {
+Parser.prototype._makeFormal = function(expr) {
   if ((expr instanceof VarExpression)) {
     return new FormalNode(false, false, null, expr.get$name(), null, expr.get$span());
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     return new FormalNode(false, false, expr.type, expr.get$name(), null, expr.get$span());
   }
   else if (this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier))) {
     var di = expr.x;
     return new FormalNode(false, false, di.type, di.name, expr.y, expr.get$span());
   }
   else if (this._isBin(expr, 52/*TokenKind.LT*/)) {
     return null;
   }
   else if ((expr instanceof ListExpression)) {
     return this._makeFormalsFromList(expr);
   }
   else {
     this._lang_error('expected formal', expr.get$span());
   }
 }
-lang_Parser.prototype._makeFormalsFromList = function(expr) {
+Parser.prototype._makeFormalsFromList = function(expr) {
   if (expr.get$isConst()) {
     this._lang_error('expected formal, but found "const"', expr.get$span());
   }
   else if ($ne(expr.type, null)) {
     this._lang_error('expected formal, but found generic type arguments', expr.type.get$span());
   }
   return this._makeFormalsFromExpressions(expr.values, false);
 }
-lang_Parser.prototype._makeFormals = function(arguments) {
+Parser.prototype._makeFormals = function(arguments) {
   var expressions = [];
   for (var i = 0;
    i < arguments.length; i++) {
     var arg = arguments.$index(i);
     if (arg.label != null) {
       this._lang_error('expected formal, but found ":"');
     }
     expressions.add(arg.get$value());
   }
   return this._makeFormalsFromExpressions(expressions, true);
 }
-lang_Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
+Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
   var formals = [];
   for (var i = 0;
    i < expressions.length; i++) {
     var formal = this._makeFormal(expressions.$index(i));
     if (formal == null) {
       var baseType = this._makeType(expressions.$index(i).x);
       var typeParams = [this._makeType(expressions.$index(i).y)];
       i++;
       while (i < expressions.length) {
         var expr = expressions.$index(i++);
@@ skipping 22 matching lines @@
       if (!allowOptional) {
         this._lang_error('unexpected nested optional formal', expressions.$index(i).get$span());
       }
     }
     else {
       formals.add(formal);
     }
   }
   return formals;
 }
-lang_Parser.prototype._makeDeclaredIdentifier = function(e) {
+Parser.prototype._makeDeclaredIdentifier = function(e) {
   if ((e instanceof VarExpression)) {
     return new DeclaredIdentifier(null, e.get$name(), e.get$span());
   }
   else if ((e instanceof DeclaredIdentifier)) {
     return e;
   }
   else {
     this._lang_error('expected declared identifier');
     return new DeclaredIdentifier(null, null, e.get$span());
   }
 }
-lang_Parser.prototype._makeLabel = function(expr) {
+Parser.prototype._makeLabel = function(expr) {
   if ((expr instanceof VarExpression)) {
     return expr.get$name();
   }
   else {
     this._errorExpected('label');
     return null;
   }
 }
-// ********** Code for lang_Node **************
-function lang_Node(span) {
+// ********** Code for Node **************
+function Node(span) {
   this.span = span;
   // Initializers done
 }
-lang_Node.prototype.get$span = function() { return this.span; };
-lang_Node.prototype.set$span = function(value) { return this.span = value; };
+Node.prototype.get$span = function() { return this.span; };
+Node.prototype.set$span = function(value) { return this.span = value; };
 // ********** Code for Definition **************
 function Definition(span) {
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(Definition, lang_Statement);
+$inherits(Definition, Statement);
 Definition.prototype.get$typeParameters = function() {
   return null;
 }
-// ********** Code for lang_Statement **************
-function lang_Statement(span) {
-  lang_Node.call(this, span);
+// ********** Code for Statement **************
+function Statement(span) {
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(lang_Statement, lang_Node);
-// ********** Code for lang_Expression **************
-function lang_Expression(span) {
-  lang_Node.call(this, span);
+$inherits(Statement, Node);
+// ********** Code for Expression **************
+function Expression(span) {
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(lang_Expression, lang_Node);
+$inherits(Expression, Node);
 // ********** Code for TypeReference **************
 function TypeReference(span, type) {
   this.type = type;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(TypeReference, lang_Node);
+$inherits(TypeReference, 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 if ((value instanceof 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) {
@@ skipping 110 matching lines @@
 FunctionDefinition.prototype.get$returnType = function() { return this.returnType; };
 FunctionDefinition.prototype.set$returnType = function(value) { return this.returnType = value; };
 FunctionDefinition.prototype.get$name = function() { return this.name; };
 FunctionDefinition.prototype.set$name = function(value) { return this.name = value; };
 FunctionDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
 }
 // ********** Code for ReturnStatement **************
 function ReturnStatement(value, span) {
   this.value = value;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(ReturnStatement, lang_Statement);
+$inherits(ReturnStatement, Statement);
 ReturnStatement.prototype.get$value = function() { return this.value; };
 ReturnStatement.prototype.set$value = function(value) { return this.value = value; };
 ReturnStatement.prototype.visit = function(visitor) {
   return visitor.visitReturnStatement(this);
 }
 // ********** Code for ThrowStatement **************
 function ThrowStatement(value, span) {
   this.value = value;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(ThrowStatement, lang_Statement);
+$inherits(ThrowStatement, Statement);
 ThrowStatement.prototype.get$value = function() { return this.value; };
 ThrowStatement.prototype.set$value = function(value) { return this.value = value; };
 ThrowStatement.prototype.visit = function(visitor) {
   return visitor.visitThrowStatement(this);
 }
 // ********** Code for AssertStatement **************
 function AssertStatement(test, span) {
   this.test = test;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(AssertStatement, lang_Statement);
+$inherits(AssertStatement, Statement);
 AssertStatement.prototype.visit = function(visitor) {
   return visitor.visitAssertStatement(this);
 }
 // ********** Code for BreakStatement **************
 function BreakStatement(label, span) {
   this.label = label;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(BreakStatement, lang_Statement);
+$inherits(BreakStatement, Statement);
 BreakStatement.prototype.visit = function(visitor) {
   return visitor.visitBreakStatement(this);
 }
 // ********** Code for ContinueStatement **************
 function ContinueStatement(label, span) {
   this.label = label;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(ContinueStatement, lang_Statement);
+$inherits(ContinueStatement, Statement);
 ContinueStatement.prototype.visit = function(visitor) {
   return visitor.visitContinueStatement(this);
 }
 // ********** Code for IfStatement **************
 function IfStatement(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(IfStatement, lang_Statement);
+$inherits(IfStatement, Statement);
 IfStatement.prototype.visit = function(visitor) {
   return visitor.visitIfStatement(this);
 }
 // ********** Code for WhileStatement **************
 function WhileStatement(test, body, span) {
   this.test = test;
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(WhileStatement, lang_Statement);
+$inherits(WhileStatement, Statement);
 WhileStatement.prototype.visit = function(visitor) {
   return visitor.visitWhileStatement(this);
 }
 // ********** Code for DoStatement **************
 function DoStatement(body, test, span) {
   this.body = body;
   this.test = test;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(DoStatement, lang_Statement);
+$inherits(DoStatement, Statement);
 DoStatement.prototype.visit = function(visitor) {
   return visitor.visitDoStatement(this);
 }
 // ********** Code for ForStatement **************
 function ForStatement(init, test, step, body, span) {
   this.init = init;
   this.test = test;
   this.step = step;
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(ForStatement, lang_Statement);
+$inherits(ForStatement, Statement);
 ForStatement.prototype.visit = function(visitor) {
   return visitor.visitForStatement(this);
 }
 // ********** Code for ForInStatement **************
 function ForInStatement(item, list, body, span) {
   this.item = item;
   this.list = list;
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(ForInStatement, lang_Statement);
+$inherits(ForInStatement, Statement);
 ForInStatement.prototype.visit = function(visitor) {
   return visitor.visitForInStatement(this);
 }
 // ********** Code for TryStatement **************
 function TryStatement(body, catches, finallyBlock, span) {
   this.body = body;
   this.catches = catches;
   this.finallyBlock = finallyBlock;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(TryStatement, lang_Statement);
+$inherits(TryStatement, Statement);
 TryStatement.prototype.visit = function(visitor) {
   return visitor.visitTryStatement(this);
 }
 // ********** Code for SwitchStatement **************
 function SwitchStatement(test, cases, span) {
   this.test = test;
   this.cases = cases;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(SwitchStatement, lang_Statement);
+$inherits(SwitchStatement, Statement);
 SwitchStatement.prototype.visit = function(visitor) {
   return visitor.visitSwitchStatement(this);
 }
 // ********** Code for BlockStatement **************
 function BlockStatement(body, span) {
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(BlockStatement, lang_Statement);
+$inherits(BlockStatement, Statement);
 BlockStatement.prototype.visit = function(visitor) {
   return visitor.visitBlockStatement(this);
 }
 // ********** Code for LabeledStatement **************
 function LabeledStatement(name, body, span) {
   this.name = name;
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(LabeledStatement, lang_Statement);
+$inherits(LabeledStatement, Statement);
 LabeledStatement.prototype.get$name = function() { return this.name; };
 LabeledStatement.prototype.set$name = function(value) { return this.name = value; };
 LabeledStatement.prototype.visit = function(visitor) {
   return visitor.visitLabeledStatement(this);
 }
-// ********** Code for lang_ExpressionStatement **************
-function lang_ExpressionStatement(body, span) {
+// ********** Code for ExpressionStatement **************
+function ExpressionStatement(body, span) {
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(lang_ExpressionStatement, lang_Statement);
-lang_ExpressionStatement.prototype.visit = function(visitor) {
+$inherits(ExpressionStatement, Statement);
+ExpressionStatement.prototype.visit = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
 // ********** Code for EmptyStatement **************
 function EmptyStatement(span) {
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(EmptyStatement, lang_Statement);
+$inherits(EmptyStatement, Statement);
 EmptyStatement.prototype.visit = function(visitor) {
   return visitor.visitEmptyStatement(this);
 }
 // ********** Code for DietStatement **************
 function DietStatement(span) {
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(DietStatement, lang_Statement);
+$inherits(DietStatement, Statement);
 DietStatement.prototype.visit = function(visitor) {
   return visitor.visitDietStatement(this);
 }
 // ********** Code for NativeStatement **************
 function NativeStatement(body, span) {
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(NativeStatement, lang_Statement);
+$inherits(NativeStatement, Statement);
 NativeStatement.prototype.visit = function(visitor) {
   return visitor.visitNativeStatement(this);
 }
 // ********** Code for LambdaExpression **************
 function LambdaExpression(func, span) {
   this.func = func;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(LambdaExpression, lang_Expression);
+$inherits(LambdaExpression, Expression);
 LambdaExpression.prototype.visit = function(visitor) {
   return visitor.visitLambdaExpression(this);
 }
 // ********** Code for CallExpression **************
 function CallExpression(target, arguments, span) {
   this.target = target;
   this.arguments = arguments;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(CallExpression, lang_Expression);
+$inherits(CallExpression, Expression);
 CallExpression.prototype.get$arguments = function() { return this.arguments; };
 CallExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
 CallExpression.prototype.visit = function(visitor) {
   return visitor.visitCallExpression(this);
 }
 // ********** Code for IndexExpression **************
 function IndexExpression(target, index, span) {
   this.target = target;
   this.index = index;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(IndexExpression, lang_Expression);
+$inherits(IndexExpression, Expression);
 IndexExpression.prototype.visit = function(visitor) {
   return visitor.visitIndexExpression(this);
 }
 // ********** Code for BinaryExpression **************
 function BinaryExpression(op, x, y, span) {
   this.op = op;
   this.x = x;
   this.y = y;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(BinaryExpression, lang_Expression);
+$inherits(BinaryExpression, Expression);
 BinaryExpression.prototype.visit = function(visitor) {
   return visitor.visitBinaryExpression(this);
 }
 // ********** Code for UnaryExpression **************
 function UnaryExpression(op, self, span) {
   this.op = op;
   this.self = self;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(UnaryExpression, lang_Expression);
+$inherits(UnaryExpression, Expression);
 UnaryExpression.prototype.visit = function(visitor) {
   return visitor.visitUnaryExpression(this);
 }
 // ********** Code for PostfixExpression **************
 function PostfixExpression(body, op, span) {
   this.body = body;
   this.op = op;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(PostfixExpression, lang_Expression);
+$inherits(PostfixExpression, Expression);
 PostfixExpression.prototype.visit = function(visitor) {
   return visitor.visitPostfixExpression$1(this);
 }
-// ********** Code for lang_NewExpression **************
-function lang_NewExpression(isConst, type, name, arguments, span) {
+// ********** Code for NewExpression **************
+function NewExpression(isConst, type, name, arguments, span) {
   this.isConst = isConst;
   this.type = type;
   this.name = name;
   this.arguments = arguments;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(lang_NewExpression, lang_Expression);
-lang_NewExpression.prototype.get$isConst = function() { return this.isConst; };
-lang_NewExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
-lang_NewExpression.prototype.get$name = function() { return this.name; };
-lang_NewExpression.prototype.set$name = function(value) { return this.name = value; };
-lang_NewExpression.prototype.get$arguments = function() { return this.arguments; };
-lang_NewExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
-lang_NewExpression.prototype.visit = function(visitor) {
+$inherits(NewExpression, Expression);
+NewExpression.prototype.get$isConst = function() { return this.isConst; };
+NewExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
+NewExpression.prototype.get$name = function() { return this.name; };
+NewExpression.prototype.set$name = function(value) { return this.name = value; };
+NewExpression.prototype.get$arguments = function() { return this.arguments; };
+NewExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
+NewExpression.prototype.visit = function(visitor) {
   return visitor.visitNewExpression(this);
 }
 // ********** Code for ListExpression **************
 function ListExpression(isConst, type, values, span) {
   this.isConst = isConst;
   this.type = type;
   this.values = values;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(ListExpression, lang_Expression);
+$inherits(ListExpression, Expression);
 ListExpression.prototype.get$isConst = function() { return this.isConst; };
 ListExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 ListExpression.prototype.visit = function(visitor) {
   return visitor.visitListExpression(this);
 }
 // ********** Code for MapExpression **************
 function MapExpression(isConst, type, items, span) {
   this.isConst = isConst;
   this.type = type;
   this.items = items;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(MapExpression, lang_Expression);
+$inherits(MapExpression, Expression);
 MapExpression.prototype.get$isConst = function() { return this.isConst; };
 MapExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 MapExpression.prototype.visit = function(visitor) {
   return visitor.visitMapExpression(this);
 }
 // ********** Code for ConditionalExpression **************
 function ConditionalExpression(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(ConditionalExpression, lang_Expression);
+$inherits(ConditionalExpression, Expression);
 ConditionalExpression.prototype.visit = function(visitor) {
   return visitor.visitConditionalExpression(this);
 }
 // ********** Code for IsExpression **************
 function IsExpression(isTrue, x, type, span) {
   this.isTrue = isTrue;
   this.x = x;
   this.type = type;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(IsExpression, lang_Expression);
+$inherits(IsExpression, Expression);
 IsExpression.prototype.visit = function(visitor) {
   return visitor.visitIsExpression(this);
 }
 // ********** Code for ParenExpression **************
 function ParenExpression(body, span) {
   this.body = body;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(ParenExpression, lang_Expression);
+$inherits(ParenExpression, Expression);
 ParenExpression.prototype.visit = function(visitor) {
   return visitor.visitParenExpression(this);
 }
 // ********** Code for DotExpression **************
 function DotExpression(self, name, span) {
   this.self = self;
   this.name = name;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(DotExpression, lang_Expression);
+$inherits(DotExpression, Expression);
 DotExpression.prototype.get$name = function() { return this.name; };
 DotExpression.prototype.set$name = function(value) { return this.name = value; };
 DotExpression.prototype.visit = function(visitor) {
   return visitor.visitDotExpression(this);
 }
 // ********** Code for VarExpression **************
 function VarExpression(name, span) {
   this.name = name;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(VarExpression, lang_Expression);
+$inherits(VarExpression, Expression);
 VarExpression.prototype.get$name = function() { return this.name; };
 VarExpression.prototype.set$name = function(value) { return this.name = value; };
 VarExpression.prototype.visit = function(visitor) {
   return visitor.visitVarExpression(this);
 }
 // ********** Code for ThisExpression **************
 function ThisExpression(span) {
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(ThisExpression, lang_Expression);
+$inherits(ThisExpression, Expression);
 ThisExpression.prototype.visit = function(visitor) {
   return visitor.visitThisExpression(this);
 }
 // ********** Code for SuperExpression **************
 function SuperExpression(span) {
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(SuperExpression, lang_Expression);
+$inherits(SuperExpression, Expression);
 SuperExpression.prototype.visit = function(visitor) {
   return visitor.visitSuperExpression(this);
 }
 // ********** Code for NullExpression **************
 function NullExpression(span) {
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(NullExpression, lang_Expression);
+$inherits(NullExpression, Expression);
 NullExpression.prototype.visit = function(visitor) {
   return visitor.visitNullExpression(this);
 }
 // ********** Code for LiteralExpression **************
 function LiteralExpression(value, type, text, span) {
   this.value = value;
   this.type = type;
   this.text = text;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(LiteralExpression, lang_Expression);
+$inherits(LiteralExpression, Expression);
 LiteralExpression.prototype.get$value = function() { return this.value; };
 LiteralExpression.prototype.set$value = function(value) { return this.value = value; };
 LiteralExpression.prototype.get$text = function() { return this.text; };
 LiteralExpression.prototype.set$text = function(value) { return this.text = value; };
 LiteralExpression.prototype.visit = function(visitor) {
   return visitor.visitLiteralExpression(this);
 }
 // ********** Code for NameTypeReference **************
 function NameTypeReference(isFinal, name, names, span) {
   this.isFinal = isFinal;
@@ skipping 28 matching lines @@
   // Initializers done
 }
 $inherits(FunctionTypeReference, TypeReference);
 FunctionTypeReference.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeReference(this);
 }
 // ********** Code for ArgumentNode **************
 function ArgumentNode(label, value, span) {
   this.label = label;
   this.value = value;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(ArgumentNode, lang_Node);
+$inherits(ArgumentNode, Node);
 ArgumentNode.prototype.get$value = function() { return this.value; };
 ArgumentNode.prototype.set$value = function(value) { return this.value = value; };
 ArgumentNode.prototype.visit = function(visitor) {
   return visitor.visitArgumentNode(this);
 }
 // ********** Code for FormalNode **************
 function FormalNode(isThis, isRest, type, name, value, span) {
   this.isThis = isThis;
   this.isRest = isRest;
   this.type = type;
   this.name = name;
   this.value = value;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(FormalNode, lang_Node);
+$inherits(FormalNode, Node);
 FormalNode.prototype.get$name = function() { return this.name; };
 FormalNode.prototype.set$name = function(value) { return this.name = value; };
 FormalNode.prototype.get$value = function() { return this.value; };
 FormalNode.prototype.set$value = function(value) { return this.value = value; };
 FormalNode.prototype.visit = function(visitor) {
   return visitor.visitFormalNode(this);
 }
 // ********** Code for CatchNode **************
 function CatchNode(exception, trace, body, span) {
   this.exception = exception;
   this.trace = trace;
   this.body = body;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(CatchNode, lang_Node);
+$inherits(CatchNode, Node);
 CatchNode.prototype.visit = function(visitor) {
   return visitor.visitCatchNode(this);
 }
 // ********** Code for CaseNode **************
 function CaseNode(label, cases, statements, span) {
   this.label = label;
   this.cases = cases;
   this.statements = statements;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(CaseNode, lang_Node);
+$inherits(CaseNode, Node);
 CaseNode.prototype.visit = function(visitor) {
   return visitor.visitCaseNode(this);
 }
 // ********** Code for TypeParameter **************
 function TypeParameter(name, extendsType, span) {
   this.name = name;
   this.extendsType = extendsType;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(TypeParameter, lang_Node);
+$inherits(TypeParameter, Node);
 TypeParameter.prototype.get$name = function() { return this.name; };
 TypeParameter.prototype.set$name = function(value) { return this.name = value; };
 TypeParameter.prototype.visit = function(visitor) {
   return visitor.visitTypeParameter(this);
 }
-// ********** Code for lang_Identifier **************
-function lang_Identifier(name, span) {
+// ********** Code for Identifier **************
+function Identifier(name, span) {
   this.name = name;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(lang_Identifier, lang_Node);
-lang_Identifier.prototype.get$name = function() { return this.name; };
-lang_Identifier.prototype.set$name = function(value) { return this.name = value; };
-lang_Identifier.prototype.visit = function(visitor) {
+$inherits(Identifier, Node);
+Identifier.prototype.get$name = function() { return this.name; };
+Identifier.prototype.set$name = function(value) { return this.name = value; };
+Identifier.prototype.visit = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 // ********** Code for DeclaredIdentifier **************
 function DeclaredIdentifier(type, name, span) {
   this.type = type;
   this.name = name;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(DeclaredIdentifier, lang_Expression);
+$inherits(DeclaredIdentifier, 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);
@@ skipping 251 matching lines @@
 }
 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) {
+// ********** Code for Type **************
+function Type(name) {
   this.name = name;
   this.isTested = false;
   // Initializers done
 }
-lang_Type.prototype.get$name = function() { return this.name; };
-lang_Type.prototype.markUsed = function() {
+Type.prototype.get$name = function() { return this.name; };
+Type.prototype.markUsed = function() {
 
 }
-lang_Type.prototype.get$typeMember = function() {
+Type.prototype.get$typeMember = function() {
   if (this._typeMember == null) {
     this._typeMember = new TypeMember(this);
   }
   return this._typeMember;
 }
-lang_Type.prototype.getMember = function(name) {
+Type.prototype.getMember = function(name) {
   return null;
 }
-lang_Type.prototype.get$isVar = function() {
+Type.prototype.get$isVar = function() {
   return false;
 }
-lang_Type.prototype.get$isTop = function() {
+Type.prototype.get$isTop = function() {
   return false;
 }
-lang_Type.prototype.get$isObject = function() {
+Type.prototype.get$isObject = function() {
   return false;
 }
-lang_Type.prototype.get$isString = function() {
+Type.prototype.get$isString = function() {
   return false;
 }
-lang_Type.prototype.get$isBool = function() {
+Type.prototype.get$isBool = function() {
   return false;
 }
-lang_Type.prototype.get$isFunction = function() {
+Type.prototype.get$isFunction = function() {
   return false;
 }
-lang_Type.prototype.get$isList = function() {
+Type.prototype.get$isList = function() {
   return false;
 }
-lang_Type.prototype.get$isNum = function() {
+Type.prototype.get$isNum = function() {
   return false;
 }
-lang_Type.prototype.get$isVarOrFunction = function() {
+Type.prototype.get$isVarOrFunction = function() {
   return this.get$isVar() || this.get$isFunction();
 }
-lang_Type.prototype.getCallMethod = function() {
+Type.prototype.getCallMethod = function() {
   return null;
 }
-lang_Type.prototype.get$isClosed = function() {
+Type.prototype.get$isClosed = function() {
   return this.get$isString() || this.get$isBool() || this.get$isNum() || this.get$isFunction();
 }
-lang_Type.prototype.get$isUsed = function() {
+Type.prototype.get$isUsed = function() {
   return false;
 }
-lang_Type.prototype.get$isGeneric = function() {
+Type.prototype.get$isGeneric = function() {
   return false;
 }
-lang_Type.prototype.get$isNativeType = function() {
+Type.prototype.get$isNativeType = function() {
   return false;
 }
-lang_Type.prototype.get$isNative = function() {
+Type.prototype.get$isNative = function() {
   return this.get$isNativeType();
 }
-lang_Type.prototype.get$hasTypeParams = function() {
+Type.prototype.get$hasTypeParams = function() {
   return false;
 }
-lang_Type.prototype.get$typeofName = function() {
+Type.prototype.get$typeofName = function() {
   return null;
 }
-lang_Type.prototype.get$jsname = function() {
+Type.prototype.get$jsname = function() {
   return this._jsname == null ? this.name : this._jsname;
 }
-lang_Type.prototype.set$jsname = function(name) {
+Type.prototype.set$jsname = function(name) {
   return this._jsname = name;
 }
-lang_Type.prototype.getAllMembers = function() {
+Type.prototype.getAllMembers = function() {
   return $map([]);
 }
-lang_Type.prototype.needsVarCall = function(args) {
+Type.prototype.needsVarCall = function(args) {
   if (this.get$isVarOrFunction()) {
     return true;
   }
   var call = this.getCallMethod();
   if ($ne(call, null)) {
     if (args.get$length() != call.get$parameters().length || !call.namesInOrder(args)) {
       return true;
     }
   }
   return false;
 }
-lang_Type.union = function(x, y) {
+Type.union = function(x, y) {
   if ($eq(x, y)) return x;
   if (x.get$isNum() && y.get$isNum()) return world.numType;
   if (x.get$isString() && y.get$isString()) return world.stringType;
   return world.varType;
 }
 // ********** Code for ParameterType **************
 function ParameterType(name, typeParameter) {
   this.typeParameter = typeParameter;
-  lang_Type.call(this, name);
+  Type.call(this, name);
   // Initializers done
 }
-$inherits(ParameterType, lang_Type);
+$inherits(ParameterType, Type);
 ParameterType.prototype.get$isClass = function() {
   return false;
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
 ParameterType.prototype.get$span = function() {
   return this.typeParameter.span;
 }
 ParameterType.prototype.getCallMethod = function() {
@@ skipping 23 matching lines @@
   }
 }
 // ********** Code for ConcreteType **************
 function ConcreteType(name, genericType, typeArguments, typeArgsInOrder) {
   this.genericType = genericType;
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
-  lang_Type.call(this, name);
+  Type.call(this, name);
   // Initializers done
 }
-$inherits(ConcreteType, lang_Type);
+$inherits(ConcreteType, Type);
 ConcreteType.prototype.get$isList = function() {
   return this.genericType.get$isList();
 }
 ConcreteType.prototype.get$isClass = function() {
   return this.genericType.get$isClass();
 }
 ConcreteType.prototype.get$library = function() {
   return this.genericType.get$library();
 }
 ConcreteType.prototype.get$span = function() {
@@ skipping 133 matching lines @@
 function DefinedType(name, library, definition, isClass) {
   this.isUsed = false
   this.isNativeType = false
   this.library = library;
   this.isClass = isClass;
   this.directSubtypes = [];
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
   this._resolvedMembers = $map([]);
-  lang_Type.call(this, name);
+  Type.call(this, name);
   // Initializers done
   this.setDefinition(definition);
 }
-$inherits(DefinedType, lang_Type);
+$inherits(DefinedType, Type);
 DefinedType.prototype.get$definition = function() { return this.definition; };
 DefinedType.prototype.set$definition = function(value) { return this.definition = value; };
 DefinedType.prototype.get$library = function() { return this.library; };
 DefinedType.prototype.get$isClass = function() { return this.isClass; };
 DefinedType.prototype.get$parent = function() { return this.parent; };
 DefinedType.prototype.set$parent = function(value) { return this.parent = value; };
 DefinedType.prototype.get$interfaces = function() { return this.interfaces; };
 DefinedType.prototype.set$interfaces = function(value) { return this.interfaces = value; };
 DefinedType.prototype.get$typeParameters = function() { return this.typeParameters; };
 DefinedType.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
@@ skipping 663 matching lines @@
   return this.exp.get$dynamic().get$actualValue();
 }
 GlobalValue.prototype.compareTo = function(other) {
   if ($eq(other, this)) {
     return 0;
   }
   else if (this.dependencies.indexOf(other, 0) >= 0) {
     return 1;
   }
   else if (other.dependencies.indexOf(this, 0) >= 0) {
-    return -1;
+    return -1.000000/*-1*/;
   }
   else if (this.dependencies.length > other.dependencies.length) {
     return 1;
   }
   else if (this.dependencies.length < other.dependencies.length) {
-    return -1;
+    return -1.000000/*-1*/;
   }
   else if (this.name == null && other.name != null) {
     return 1;
   }
   else if (this.name != null && other.name == null) {
-    return -1;
+    return -1.000000/*-1*/;
   }
   else if (this.name != null) {
     return this.name.compareTo(other.name);
   }
   else {
     return this.field.name.compareTo(other.field.name);
   }
 }
 // ********** Code for CompilerException **************
 function CompilerException(_message, _location) {
-  this._message = _message;
+  this._lang_message = _message;
   this._location = _location;
   // Initializers done
 }
 CompilerException.prototype.toString = function() {
   if (this._location != null) {
-    return ('CompilerException: ' + this._location.toMessageString(this._message) + '');
+    return ('CompilerException: ' + this._location.toMessageString(this._lang_message) + '');
   }
   else {
-    return ('CompilerException: ' + this._message + '');
+    return ('CompilerException: ' + this._lang_message + '');
   }
 }
 // ********** Code for World **************
 function World(files) {
   this.errors = 0
   this.warnings = 0
   this.dartBytesRead = 0
   this.jsBytesWritten = 0
   this.seenFatal = false
   this.files = files;
@@ skipping 117 matching lines @@
       throw exc;
     }
   }
   this.printStatus();
   return !this.get$hasErrors();
 }
 World.prototype.runLeg = function() {
   var $this = this; // closure support
   if (!options.enableLeg) return false;
   return this.withTiming('try leg compile', (function () {
-    return compile($this);
+    return leg_compile($this);
   })
   );
 }
 World.prototype.runCompilationPhases = function() {
   var $this = this; // closure support
   var lib = this.withTiming('first pass', (function () {
     return $this.processScript(options.dartScript);
   })
   );
   this.withTiming('resolve top level', (function () {
@@ skipping 73 matching lines @@
   this.process();
   return library;
 }
 World.prototype.resolveAll = function() {
   var $list = this.libraries.getValues();
   for (var $i = this.libraries.getValues().iterator(); $i.hasNext(); ) {
     var lib = $i.next();
     lib.resolve();
   }
 }
-World.prototype._message = function(message, location, throwing) {
+World.prototype._lang_message = function(message, location, throwing) {
   var text = message;
   if (location != null) {
     text = location.toMessageString(message);
   }
   print(text);
   if (throwing) {
     $throw(new CompilerException(message, location));
   }
 }
 World.prototype.error = function(message, location) {
   this.errors++;
-  this._message(('error: ' + message + ''), location, options.throwOnErrors);
+  this._lang_message(('error: ' + message + ''), location, options.throwOnErrors);
 }
 World.prototype.warning = function(message, location) {
   this.warnings++;
   if (options.showWarnings) {
-    this._message(('warning: ' + message + ''), location, options.throwOnWarnings);
+    this._lang_message(('warning: ' + message + ''), location, options.throwOnWarnings);
   }
 }
 World.prototype.fatal = function(message, location) {
   this.errors++;
   this.seenFatal = true;
-  this._message(('fatal: ' + message + ''), location, options.throwOnFatal || options.throwOnErrors);
+  this._lang_message(('fatal: ' + message + ''), location, options.throwOnFatal || options.throwOnErrors);
 }
 World.prototype.internalError = function(message, location) {
-  this._message(('We are sorry, but... ' + message + ''), location, true);
+  this._lang_message(('We are sorry, but... ' + message + ''), location, true);
 }
 World.prototype.info = function(message, location) {
   if (options.showInfo) {
-    this._message(('info: ' + message + ''), location, false);
+    this._lang_message(('info: ' + message + ''), location, false);
   }
 }
 World.prototype.get$hasErrors = function() {
   return this.errors > 0;
 }
 World.prototype.printStatus = function() {
   this.info(('compiled ' + this.dartBytesRead + ' bytes Dart -> ' + this.jsBytesWritten + ' bytes JS'));
   if (this.get$hasErrors()) {
     print(('compilation failed with ' + this.errors + ' errors'));
   }
@@ skipping 33 matching lines @@
   var ignoreUnrecognizedFlags = false;
   loop:
   for (var i = 2;
    i < args.length; i++) {
     var arg = args.$index(i);
     switch (arg) {
       case '--enable_leg':
 
         this.enableLeg = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 59))
 
       case '--enable_asserts':
 
         this.enableAsserts = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 63))
 
       case '--enable_type_checks':
 
         this.enableTypeChecks = true;
         this.enableAsserts = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 69))
 
       case '--verify_implements':
 
         this.verifyImplements = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 73))
 
       case '--compile_all':
 
         this.compileAll = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 77))
 
       case '--diet-parse':
 
         this.dietParse = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 81))
 
       case '--ignore-unrecognized-flags':
 
         ignoreUnrecognizedFlags = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 85))
 
       case '--verbose':
 
         this.showInfo = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 89))
 
       case '--throw_on_errors':
 
         this.throwOnErrors = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 93))
 
       case '--throw_on_warnings':
 
         this.throwOnWarnings = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 97))
 
       case '--compile-only':
 
         this.compileOnly = true;
         continue loop;
+        $throw(new FallThroughError("./options.dart", 102))
 
       default:
 
         if (arg.endsWith('.dart')) {
           this.dartScript = arg;
           this.childArgs = ListFactory.ListFactory$fromList$factory(args, i + 1, args.length);
           return;
         }
         else if (arg.startsWith('--out=')) {
           this.outfile = arg.substring('--out='.length);
@@ skipping 49 matching lines @@
   }
   else {
     return text;
   }
 }
 var world;
 function initializeWorld(files) {
   world = new World(files);
   world.init();
 }
-function lang_compile(homedir, args) {
+function compile(homedir, args) {
   parseOptions(homedir, args);
   initializeWorld(new FileSystem(options.libDir));
   var success = world.compile();
   if (options.outfile != null) {
     if (success) {
       var code = world.getGeneratedCode();
       if (!options.outfile.endsWith('.js')) {
         code = '#!/usr/bin/env node\n' + code;
       }
       world.files.writeString(options.outfile, code);
     }
     else {
       world.files.writeString(options.outfile, "throw 'Sorry, but I could not generate reasonable code to run.\\n';");
     }
   }
   return success;
 }
 var options;
 function parseOptions(homedir, args) {
   options = new Options(homedir, args);
 }
 //  ********** Library frog **************
 // ********** Code for top level **************
 function main() {
   var homedir = get$path().dirname(get$fs().realpathSync(process.argv.$index(1)));
-  if (lang_compile(homedir, process.argv)) {
+  if (compile(homedir, process.argv)) {
     var code = world.getGeneratedCode();
     if (!options.compileOnly) {
       process.argv = [process.argv.$index(0), process.argv.$index(1)];
       process.argv.addAll(options.childArgs);
       runCodeWithContext(code);
     }
   }
   else {
     process.exit(1);
   }
@@ skipping 10 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$10 = new EmptyQueueException()/*const EmptyQueueException()*/;
-var const$132 = new TokenString('void')/*const TokenString('void')*/;
-var const$134 = new TokenString('int')/*const TokenString('int')*/;
-var const$136 = new TokenString('Dynamic')/*const TokenString('Dynamic')*/;
-var const$235 = new Keyword("break", false)/*const Keyword("break")*/;
-var const$237 = new Keyword("case", false)/*const Keyword("case")*/;
-var const$239 = new Keyword("catch", false)/*const Keyword("catch")*/;
-var const$241 = new Keyword("const", false)/*const Keyword("const")*/;
-var const$243 = new Keyword("continue", false)/*const Keyword("continue")*/;
-var const$245 = new Keyword("default", false)/*const Keyword("default")*/;
-var const$247 = new Keyword("do", false)/*const Keyword("do")*/;
-var const$249 = new Keyword("else", false)/*const Keyword("else")*/;
-var const$251 = new Keyword("false", false)/*const Keyword("false")*/;
-var const$253 = new Keyword("final", false)/*const Keyword("final")*/;
-var const$255 = new Keyword("finally", false)/*const Keyword("finally")*/;
-var const$257 = new Keyword("for", false)/*const Keyword("for")*/;
-var const$259 = new Keyword("if", false)/*const Keyword("if")*/;
-var const$261 = new Keyword("in", false)/*const Keyword("in")*/;
-var const$263 = new Keyword("is", false)/*const Keyword("is")*/;
-var const$265 = new Keyword("new", false)/*const Keyword("new")*/;
-var const$267 = new Keyword("null", false)/*const Keyword("null")*/;
-var const$269 = new Keyword("return", false)/*const Keyword("return")*/;
-var const$271 = new Keyword("super", false)/*const Keyword("super")*/;
-var const$273 = new Keyword("switch", false)/*const Keyword("switch")*/;
-var const$275 = new Keyword("this", false)/*const Keyword("this")*/;
-var const$277 = new Keyword("throw", false)/*const Keyword("throw")*/;
-var const$279 = new Keyword("true", false)/*const Keyword("true")*/;
-var const$281 = new Keyword("try", false)/*const Keyword("try")*/;
-var const$283 = new Keyword("var", false)/*const Keyword("var")*/;
-var const$285 = new Keyword("void", false)/*const Keyword("void")*/;
-var const$287 = new Keyword("while", false)/*const Keyword("while")*/;
-var const$289 = new Keyword("abstract", true)/*const Keyword("abstract", true)*/;
-var const$291 = new Keyword("assert", true)/*const Keyword("assert", true)*/;
-var const$293 = new Keyword("class", true)/*const Keyword("class", true)*/;
-var const$295 = new Keyword("extends", true)/*const Keyword("extends", true)*/;
-var const$297 = new Keyword("factory", true)/*const Keyword("factory", true)*/;
-var const$299 = new Keyword("get", true)/*const Keyword("get", true)*/;
-var const$301 = new Keyword("implements", true)/*const Keyword("implements", true)*/;
-var const$303 = new Keyword("import", true)/*const Keyword("import", true)*/;
-var const$305 = new Keyword("interface", true)/*const Keyword("interface", true)*/;
-var const$307 = new Keyword("library", true)/*const Keyword("library", true)*/;
-var const$309 = new Keyword("native", true)/*const Keyword("native", true)*/;
-var const$311 = new Keyword("negate", true)/*const Keyword("negate", true)*/;
-var const$313 = new Keyword("operator", true)/*const Keyword("operator", true)*/;
-var const$315 = new Keyword("set", true)/*const Keyword("set", true)*/;
-var const$317 = new Keyword("source", true)/*const Keyword("source", true)*/;
-var const$319 = new Keyword("static", true)/*const Keyword("static", true)*/;
-var const$321 = new Keyword("typedef", true)/*const Keyword("typedef", true)*/;
-var const$325 = new LinkTail()/*const LinkTail()*/;
-var const$8 = []/*const []*/;
-var const$9 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
+var const$120 = []/*const []*/;
+var const$121 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
+var const$122 = new EmptyQueueException()/*const EmptyQueueException()*/;
+var const$227 = new Keyword("break", false)/*const Keyword("break")*/;
+var const$229 = new Keyword("case", false)/*const Keyword("case")*/;
+var const$231 = new Keyword("catch", false)/*const Keyword("catch")*/;
+var const$233 = new Keyword("const", false)/*const Keyword("const")*/;
+var const$235 = new Keyword("continue", false)/*const Keyword("continue")*/;
+var const$237 = new Keyword("default", false)/*const Keyword("default")*/;
+var const$239 = new Keyword("do", false)/*const Keyword("do")*/;
+var const$241 = new Keyword("else", false)/*const Keyword("else")*/;
+var const$243 = new Keyword("false", false)/*const Keyword("false")*/;
+var const$245 = new Keyword("final", false)/*const Keyword("final")*/;
+var const$247 = new Keyword("finally", false)/*const Keyword("finally")*/;
+var const$249 = new Keyword("for", false)/*const Keyword("for")*/;
+var const$251 = new Keyword("if", false)/*const Keyword("if")*/;
+var const$253 = new Keyword("in", false)/*const Keyword("in")*/;
+var const$255 = new Keyword("is", false)/*const Keyword("is")*/;
+var const$257 = new Keyword("new", false)/*const Keyword("new")*/;
+var const$259 = new Keyword("null", false)/*const Keyword("null")*/;
+var const$261 = new Keyword("return", false)/*const Keyword("return")*/;
+var const$263 = new Keyword("super", false)/*const Keyword("super")*/;
+var const$265 = new Keyword("switch", false)/*const Keyword("switch")*/;
+var const$267 = new Keyword("this", false)/*const Keyword("this")*/;
+var const$269 = new Keyword("throw", false)/*const Keyword("throw")*/;
+var const$271 = new Keyword("true", false)/*const Keyword("true")*/;
+var const$273 = new Keyword("try", false)/*const Keyword("try")*/;
+var const$275 = new Keyword("var", false)/*const Keyword("var")*/;
+var const$277 = new Keyword("void", false)/*const Keyword("void")*/;
+var const$279 = new Keyword("while", false)/*const Keyword("while")*/;
+var const$281 = new Keyword("abstract", true)/*const Keyword("abstract", true)*/;
+var const$283 = new Keyword("assert", true)/*const Keyword("assert", true)*/;
+var const$285 = new Keyword("class", true)/*const Keyword("class", true)*/;
+var const$287 = new Keyword("extends", true)/*const Keyword("extends", true)*/;
+var const$289 = new Keyword("factory", true)/*const Keyword("factory", true)*/;
+var const$291 = new Keyword("get", true)/*const Keyword("get", true)*/;
+var const$293 = new Keyword("implements", true)/*const Keyword("implements", true)*/;
+var const$295 = new Keyword("import", true)/*const Keyword("import", true)*/;
+var const$297 = new Keyword("interface", true)/*const Keyword("interface", true)*/;
+var const$299 = new Keyword("library", true)/*const Keyword("library", true)*/;
+var const$301 = new Keyword("native", true)/*const Keyword("native", true)*/;
+var const$303 = new Keyword("negate", true)/*const Keyword("negate", true)*/;
+var const$305 = new Keyword("operator", true)/*const Keyword("operator", true)*/;
+var const$307 = new Keyword("set", true)/*const Keyword("set", true)*/;
+var const$309 = new Keyword("source", true)/*const Keyword("source", true)*/;
+var const$311 = new Keyword("static", true)/*const Keyword("static", true)*/;
+var const$313 = new Keyword("typedef", true)/*const Keyword("typedef", true)*/;
+var const$317 = new LinkTail()/*const LinkTail()*/;
+var const$320 = new TokenString('void')/*const TokenString('void')*/;
+var const$322 = new TokenString('int')/*const TokenString('int')*/;
+var const$324 = new TokenString('Dynamic')/*const TokenString('Dynamic')*/;
 var $0 = 48;
 var $1 = 49;
 var $2 = 50;
 var $3 = 51;
 var $4 = 52;
 var $5 = 53;
 var $6 = 54;
 var $7 = 55;
 var $8 = 56;
 var $9 = 57;
@@ skipping 170 matching lines @@
 TokenKind.LBRACE = 6;
 TokenKind.LBRACK = 4;
 TokenKind.LIBRARY = 79;
 Math.LN10 = 2.302585092994046;
 Math.LN2 = 0.6931471805599453;
 Math.LOG10E = 0.4342944819032518;
 Math.LOG2E = 1.4426950408889634;
 TokenKind.LPAREN = 2;
 TokenKind.LT = 52;
 TokenKind.LTE = 54;
-Duration.MILLISECONDS_PER_DAY = 86400000/*MILLISECONDS_PER_HOUR * HOURS_PER_DAY*/;
-Duration.MILLISECONDS_PER_HOUR = 3600000/*MILLISECONDS_PER_MINUTE * MINUTES_PER_HOUR*/;
-Duration.MILLISECONDS_PER_MINUTE = 60000/*MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE*/;
+Duration.MILLISECONDS_PER_DAY = 86400000.000000/*MILLISECONDS_PER_HOUR * HOURS_PER_DAY*/;
+Duration.MILLISECONDS_PER_HOUR = 3600000.000000/*MILLISECONDS_PER_MINUTE * MINUTES_PER_HOUR*/;
+Duration.MILLISECONDS_PER_MINUTE = 60000.000000/*MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE*/;
 Duration.MILLISECONDS_PER_SECOND = 1000;
 Duration.MINUTES_PER_HOUR = 60;
 TokenKind.MOD = 47;
 TokenKind.MUL = 44;
 TokenKind.NATIVE = 80;
 TokenKind.NE = 49;
 TokenKind.NEGATE = 81;
 TokenKind.NEW = 102;
 CodeWriter.NEWLINE = '\n';
 TokenKind.NE_STRICT = 51;
@@ skipping 33 matching lines @@
 TokenKind.TRUE = 109;
 TokenKind.TRUNCDIV = 46;
 TokenKind.TRY = 110;
 TokenKind.TYPEDEF = 86;
 TokenKind.VAR = 111;
 TokenKind.VOID = 112;
 TokenKind.WHILE = 113;
 TokenKind.WHITESPACE = 62;
 HashMapImplementation._INITIAL_CAPACITY = 8;
 var _SPAWNED_SIGNAL = "spawned";
-var const$133 = new SimpleType(const$132)/*const SimpleType(const TokenString('void'))*/;
-var const$135 = new SimpleType(const$134)/*const SimpleType(const TokenString('int'))*/;
-var const$137 = new SimpleType(const$136)/*const SimpleType(const TokenString('Dynamic'))*/;
-Keyword.ABSTRACT = const$289/*const Keyword("abstract", true)*/;
-Keyword.ASSERT = const$291/*const Keyword("assert", true)*/;
-Keyword.BREAK = const$235/*const Keyword("break")*/;
-Keyword.CASE = const$237/*const Keyword("case")*/;
-Keyword.CATCH = const$239/*const Keyword("catch")*/;
-Keyword.CLASS = const$293/*const Keyword("class", true)*/;
-Keyword.CONST = const$241/*const Keyword("const")*/;
-Keyword.CONTINUE = const$243/*const Keyword("continue")*/;
-Keyword.DEFAULT = const$245/*const Keyword("default")*/;
-Keyword.DO = const$247/*const Keyword("do")*/;
-Keyword.ELSE = const$249/*const Keyword("else")*/;
-Keyword.EXTENDS = const$295/*const Keyword("extends", true)*/;
-Keyword.FACTORY = const$297/*const Keyword("factory", true)*/;
-Keyword.FALSE = const$251/*const Keyword("false")*/;
-Keyword.FINAL = const$253/*const Keyword("final")*/;
-Keyword.FINALLY = const$255/*const Keyword("finally")*/;
-Keyword.FOR = const$257/*const Keyword("for")*/;
-Keyword.GET = const$299/*const Keyword("get", true)*/;
-Keyword.IF = const$259/*const Keyword("if")*/;
-Keyword.IMPLEMENTS = const$301/*const Keyword("implements", true)*/;
-Keyword.IMPORT = const$303/*const Keyword("import", true)*/;
-Keyword.IN = const$261/*const Keyword("in")*/;
-Keyword.INTERFACE = const$305/*const Keyword("interface", true)*/;
-Keyword.IS = const$263/*const Keyword("is")*/;
-Keyword.LIBRARY = const$307/*const Keyword("library", true)*/;
-Keyword.NATIVE = const$309/*const Keyword("native", true)*/;
-Keyword.NEGATE = const$311/*const Keyword("negate", true)*/;
-Keyword.NEW = const$265/*const Keyword("new")*/;
-Keyword.NULL = const$267/*const Keyword("null")*/;
-Keyword.OPERATOR = const$313/*const Keyword("operator", true)*/;
-Keyword.RETURN = const$269/*const Keyword("return")*/;
-Keyword.SET = const$315/*const Keyword("set", true)*/;
-Keyword.SOURCE = const$317/*const Keyword("source", true)*/;
-Keyword.STATIC = const$319/*const Keyword("static", true)*/;
-Keyword.SUPER = const$271/*const Keyword("super")*/;
-Keyword.SWITCH = const$273/*const Keyword("switch")*/;
-Keyword.THIS = const$275/*const Keyword("this")*/;
-Keyword.THROW = const$277/*const Keyword("throw")*/;
-Keyword.TRUE = const$279/*const Keyword("true")*/;
-Keyword.TRY = const$281/*const Keyword("try")*/;
-Keyword.TYPEDEF = const$321/*const Keyword("typedef", true)*/;
-Keyword.VAR = const$283/*const Keyword("var")*/;
-Keyword.VOID = const$285/*const Keyword("void")*/;
-Keyword.WHILE = const$287/*const Keyword("while")*/;
-var const$323 = [const$235, const$237, const$239, const$241, const$243, const$245, const$247, const$249, const$251, const$253, const$255, const$257, const$259, const$261, const$263, const$265, const$267, const$269, const$271, const$273, const$275, const$277, const$279, const$281, const$283, const$285, const$287, const$289, const$291, const$293, const$295, const$297, const$299, const$301, const$303, const$305, const$307, const$309, const$311, const$313, const$315, const$317, const$319, const$321]/*const <Keyword> [
+var const$321 = new SimpleType(const$320)/*const SimpleType(const TokenString('void'))*/;
+var const$323 = new SimpleType(const$322)/*const SimpleType(const TokenString('int'))*/;
+var const$325 = new SimpleType(const$324)/*const SimpleType(const TokenString('Dynamic'))*/;
+Keyword.ABSTRACT = const$281/*const Keyword("abstract", true)*/;
+Keyword.ASSERT = const$283/*const Keyword("assert", true)*/;
+Keyword.BREAK = const$227/*const Keyword("break")*/;
+Keyword.CASE = const$229/*const Keyword("case")*/;
+Keyword.CATCH = const$231/*const Keyword("catch")*/;
+Keyword.CLASS = const$285/*const Keyword("class", true)*/;
+Keyword.CONST = const$233/*const Keyword("const")*/;
+Keyword.CONTINUE = const$235/*const Keyword("continue")*/;
+Keyword.DEFAULT = const$237/*const Keyword("default")*/;
+Keyword.DO = const$239/*const Keyword("do")*/;
+Keyword.ELSE = const$241/*const Keyword("else")*/;
+Keyword.EXTENDS = const$287/*const Keyword("extends", true)*/;
+Keyword.FACTORY = const$289/*const Keyword("factory", true)*/;
+Keyword.FALSE = const$243/*const Keyword("false")*/;
+Keyword.FINAL = const$245/*const Keyword("final")*/;
+Keyword.FINALLY = const$247/*const Keyword("finally")*/;
+Keyword.FOR = const$249/*const Keyword("for")*/;
+Keyword.GET = const$291/*const Keyword("get", true)*/;
+Keyword.IF = const$251/*const Keyword("if")*/;
+Keyword.IMPLEMENTS = const$293/*const Keyword("implements", true)*/;
+Keyword.IMPORT = const$295/*const Keyword("import", true)*/;
+Keyword.IN = const$253/*const Keyword("in")*/;
+Keyword.INTERFACE = const$297/*const Keyword("interface", true)*/;
+Keyword.IS = const$255/*const Keyword("is")*/;
+Keyword.LIBRARY = const$299/*const Keyword("library", true)*/;
+Keyword.NATIVE = const$301/*const Keyword("native", true)*/;
+Keyword.NEGATE = const$303/*const Keyword("negate", true)*/;
+Keyword.NEW = const$257/*const Keyword("new")*/;
+Keyword.NULL = const$259/*const Keyword("null")*/;
+Keyword.OPERATOR = const$305/*const Keyword("operator", true)*/;
+Keyword.RETURN = const$261/*const Keyword("return")*/;
+Keyword.SET = const$307/*const Keyword("set", true)*/;
+Keyword.SOURCE = const$309/*const Keyword("source", true)*/;
+Keyword.STATIC = const$311/*const Keyword("static", true)*/;
+Keyword.SUPER = const$263/*const Keyword("super")*/;
+Keyword.SWITCH = const$265/*const Keyword("switch")*/;
+Keyword.THIS = const$267/*const Keyword("this")*/;
+Keyword.THROW = const$269/*const Keyword("throw")*/;
+Keyword.TRUE = const$271/*const Keyword("true")*/;
+Keyword.TRY = const$273/*const Keyword("try")*/;
+Keyword.TYPEDEF = const$313/*const Keyword("typedef", true)*/;
+Keyword.VAR = const$275/*const Keyword("var")*/;
+Keyword.VOID = const$277/*const Keyword("void")*/;
+Keyword.WHILE = const$279/*const Keyword("while")*/;
+var const$315 = [const$227, const$229, const$231, const$233, const$235, const$237, const$239, const$241, const$243, const$245, const$247, const$249, const$251, const$253, const$255, const$257, const$259, const$261, const$263, const$265, const$267, const$269, const$271, const$273, const$275, const$277, const$279, const$281, const$283, const$285, const$287, const$289, const$291, const$293, const$295, const$297, const$299, const$301, const$303, const$305, const$307, const$309, const$311, const$313]/*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 ]*/;
-Keyword.values = const$323/*const <Keyword> [
+Keyword.values = const$315/*const <Keyword> [
       BREAK,
       CASE,
       CATCH,
       CONST,
       CONTINUE,
       DEFAULT,
       DO,
       ELSE,
       FALSE,
       FINAL,
@@ skipping 25 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();