Make 'class' and 'extends' into real keywords, per language spec 0.06 .

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { return this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 4960 matching lines @@
 FieldMember.prototype.get$isField = function() {
   return true;
 }
 FieldMember.prototype.resolve = function() {
   this.isStatic = this.declaringType.get$isTop();
   this.isFinal = false;
   if (this.definition.modifiers != null) {
     var $$list = this.definition.modifiers;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
       var mod = $$list.$index($$i);
-      if ($eq(mod.get$kind(), 86/*TokenKind.STATIC*/)) {
+      if ($eq(mod.get$kind(), 84/*TokenKind.STATIC*/)) {
         if (this.isStatic) {
           $globals.world.error('duplicate static modifier', mod.get$span());
         }
         this.isStatic = true;
       }
       else if ($eq(mod.get$kind(), 98/*TokenKind.FINAL*/)) {
         if (this.isFinal) {
           $globals.world.error('duplicate final modifier', mod.get$span());
         }
         this.isFinal = true;
@@ skipping 990 matching lines @@
 }
 MethodMember.prototype.resolve = function() {
   this.isStatic = this.declaringType.get$isTop();
   this.isConst = false;
   this.isFactory = false;
   this.isAbstract = !this.declaringType.get$isClass();
   if (this.definition.modifiers != null) {
     var $$list = this.definition.modifiers;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
       var mod = $$list.$index($$i);
-      if ($eq(mod.get$kind(), 86/*TokenKind.STATIC*/)) {
+      if ($eq(mod.get$kind(), 84/*TokenKind.STATIC*/)) {
         if (this.isStatic) {
           $globals.world.error('duplicate static modifier', mod.get$span());
         }
         this.isStatic = true;
       }
-      else if (this.get$isConstructor() && $eq(mod.get$kind(), 92/*TokenKind.CONST*/)) {
+      else if (this.get$isConstructor() && $eq(mod.get$kind(), 91/*TokenKind.CONST*/)) {
         if (this.isConst) {
           $globals.world.error('duplicate const modifier', mod.get$span());
         }
         this.isConst = true;
       }
-      else if ($eq(mod.get$kind(), 75/*TokenKind.FACTORY*/)) {
+      else if ($eq(mod.get$kind(), 73/*TokenKind.FACTORY*/)) {
         if (this.isFactory) {
           $globals.world.error('duplicate factory modifier', mod.get$span());
         }
         this.isFactory = true;
       }
       else if ($eq(mod.get$kind(), 71/*TokenKind.ABSTRACT*/)) {
         if (this.isAbstract) {
           if (this.declaringType.get$isClass()) {
             $globals.world.error('duplicate abstract modifier', mod.get$span());
           }
@@ skipping 1259 matching lines @@
       }
 
   }
 }
 Tokenizer.prototype.getIdentifierKind = function() {
   var i0 = this._startIndex;
   switch (this._index - i0) {
     case 2:
 
       if (this._text.charCodeAt(i0) == 100) {
-        if (this._text.charCodeAt(i0 + 1) == 111) return 95/*TokenKind.DO*/;
+        if (this._text.charCodeAt(i0 + 1) == 111) return 94/*TokenKind.DO*/;
       }
       else if (this._text.charCodeAt(i0) == 105) {
         if (this._text.charCodeAt(i0 + 1) == 102) {
           return 101/*TokenKind.IF*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 110) {
           return 102/*TokenKind.IN*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 115) {
           return 103/*TokenKind.IS*/;
         }
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 3:
 
       if (this._text.charCodeAt(i0) == 102) {
         if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 114) return 100/*TokenKind.FOR*/;
       }
       else if (this._text.charCodeAt(i0) == 103) {
-        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 76/*TokenKind.GET*/;
+        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 74/*TokenKind.GET*/;
       }
       else if (this._text.charCodeAt(i0) == 110) {
         if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 119) return 104/*TokenKind.NEW*/;
       }
       else if (this._text.charCodeAt(i0) == 115) {
-        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 84/*TokenKind.SET*/;
+        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 82/*TokenKind.SET*/;
       }
       else if (this._text.charCodeAt(i0) == 116) {
         if (this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 121) return 112/*TokenKind.TRY*/;
       }
       else if (this._text.charCodeAt(i0) == 118) {
         if (this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 114) return 113/*TokenKind.VAR*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     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 90/*TokenKind.CASE*/;
+        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 96/*TokenKind.ELSE*/;
+        if (this._text.charCodeAt(i0 + 1) == 108 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101) return 95/*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 105/*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 109/*TokenKind.THIS*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 114) {
           if (this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 101) return 111/*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 114/*TokenKind.VOID*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 5:
 
       if (this._text.charCodeAt(i0) == 97) {
-        if (this._text.charCodeAt(i0 + 1) == 119 && this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 105 && this._text.charCodeAt(i0 + 4) == 116) return 88/*TokenKind.AWAIT*/;
+        if (this._text.charCodeAt(i0 + 1) == 119 && this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 105 && this._text.charCodeAt(i0 + 4) == 116) return 86/*TokenKind.AWAIT*/;
       }
       else 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 89/*TokenKind.BREAK*/;
+        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 91/*TokenKind.CATCH*/;
+          if (this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 99 && this._text.charCodeAt(i0 + 4) == 104) return 89/*TokenKind.CATCH*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 108) {
-          if (this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 115) return 73/*TokenKind.CLASS*/;
+          if (this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 115) return 90/*TokenKind.CLASS*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 111) {
-          if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 116) return 92/*TokenKind.CONST*/;
+          if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 116) return 91/*TokenKind.CONST*/;
         }
       }
       else if (this._text.charCodeAt(i0) == 102) {
         if (this._text.charCodeAt(i0 + 1) == 97) {
           if (this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 101) return 97/*TokenKind.FALSE*/;
         }
         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) return 98/*TokenKind.FINAL*/;
         }
       }
       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 107/*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 110/*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 115/*TokenKind.WHILE*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     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 72/*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 78/*TokenKind.IMPORT*/;
+        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 76/*TokenKind.IMPORT*/;
       }
       else if (this._text.charCodeAt(i0) == 110) {
         if (this._text.charCodeAt(i0 + 1) == 97) {
-          if (this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 105 && this._text.charCodeAt(i0 + 4) == 118 && this._text.charCodeAt(i0 + 5) == 101) return 81/*TokenKind.NATIVE*/;
+          if (this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 105 && this._text.charCodeAt(i0 + 4) == 118 && this._text.charCodeAt(i0 + 5) == 101) return 79/*TokenKind.NATIVE*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 101) {
-          if (this._text.charCodeAt(i0 + 2) == 103 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 116 && this._text.charCodeAt(i0 + 5) == 101) return 82/*TokenKind.NEGATE*/;
+          if (this._text.charCodeAt(i0 + 2) == 103 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 116 && this._text.charCodeAt(i0 + 5) == 101) return 80/*TokenKind.NEGATE*/;
         }
       }
       else if (this._text.charCodeAt(i0) == 114) {
         if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 117 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 110) return 106/*TokenKind.RETURN*/;
       }
       else if (this._text.charCodeAt(i0) == 115) {
         if (this._text.charCodeAt(i0 + 1) == 111) {
-          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 85/*TokenKind.SOURCE*/;
+          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 83/*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 86/*TokenKind.STATIC*/;
+          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 84/*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 108/*TokenKind.SWITCH*/;
         }
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     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 94/*TokenKind.DEFAULT*/;
+        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 93/*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 74/*TokenKind.EXTENDS*/;
+        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 96/*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 75/*TokenKind.FACTORY*/;
+          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 73/*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 99/*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 80/*TokenKind.LIBRARY*/;
+        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 78/*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 87/*TokenKind.TYPEDEF*/;
+        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 85/*TokenKind.TYPEDEF*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     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 71/*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 93/*TokenKind.CONTINUE*/;
+        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 92/*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 83/*TokenKind.OPERATOR*/;
+        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 81/*TokenKind.OPERATOR*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     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 79/*TokenKind.INTERFACE*/;
+      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 77/*TokenKind.INTERFACE*/;
       return 70/*TokenKind.IDENTIFIER*/;
 
     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 77/*TokenKind.IMPLEMENTS*/;
+      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 75/*TokenKind.IMPLEMENTS*/;
       return 70/*TokenKind.IDENTIFIER*/;
 
     default:
 
       return 70/*TokenKind.IDENTIFIER*/;
 
   }
 }
 Tokenizer.prototype.next$0 = Tokenizer.prototype.next;
 // ********** Code for TokenKind **************
@@ skipping 281 matching lines @@
       return "identifier";
 
     case 71/*TokenKind.ABSTRACT*/:
 
       return "pseudo-keyword 'abstract'";
 
     case 72/*TokenKind.ASSERT*/:
 
       return "pseudo-keyword 'assert'";
 
-    case 73/*TokenKind.CLASS*/:
+    case 90/*TokenKind.CLASS*/:
 
       return "pseudo-keyword 'class'";
 
-    case 74/*TokenKind.EXTENDS*/:
+    case 96/*TokenKind.EXTENDS*/:
 
       return "pseudo-keyword 'extends'";
 
-    case 75/*TokenKind.FACTORY*/:
+    case 73/*TokenKind.FACTORY*/:
 
       return "pseudo-keyword 'factory'";
 
-    case 76/*TokenKind.GET*/:
+    case 74/*TokenKind.GET*/:
 
       return "pseudo-keyword 'get'";
 
-    case 77/*TokenKind.IMPLEMENTS*/:
+    case 75/*TokenKind.IMPLEMENTS*/:
 
       return "pseudo-keyword 'implements'";
 
-    case 78/*TokenKind.IMPORT*/:
+    case 76/*TokenKind.IMPORT*/:
 
       return "pseudo-keyword 'import'";
 
-    case 79/*TokenKind.INTERFACE*/:
+    case 77/*TokenKind.INTERFACE*/:
 
       return "pseudo-keyword 'interface'";
 
-    case 80/*TokenKind.LIBRARY*/:
+    case 78/*TokenKind.LIBRARY*/:
 
       return "pseudo-keyword 'library'";
 
-    case 81/*TokenKind.NATIVE*/:
+    case 79/*TokenKind.NATIVE*/:
 
       return "pseudo-keyword 'native'";
 
-    case 82/*TokenKind.NEGATE*/:
+    case 80/*TokenKind.NEGATE*/:
 
       return "pseudo-keyword 'negate'";
 
-    case 83/*TokenKind.OPERATOR*/:
+    case 81/*TokenKind.OPERATOR*/:
 
       return "pseudo-keyword 'operator'";
 
-    case 84/*TokenKind.SET*/:
+    case 82/*TokenKind.SET*/:
 
       return "pseudo-keyword 'set'";
 
-    case 85/*TokenKind.SOURCE*/:
+    case 83/*TokenKind.SOURCE*/:
 
       return "pseudo-keyword 'source'";
 
-    case 86/*TokenKind.STATIC*/:
+    case 84/*TokenKind.STATIC*/:
 
       return "pseudo-keyword 'static'";
 
-    case 87/*TokenKind.TYPEDEF*/:
+    case 85/*TokenKind.TYPEDEF*/:
 
       return "pseudo-keyword 'typedef'";
 
-    case 88/*TokenKind.AWAIT*/:
+    case 86/*TokenKind.AWAIT*/:
 
       return "keyword 'await'";
 
-    case 89/*TokenKind.BREAK*/:
+    case 87/*TokenKind.BREAK*/:
 
       return "keyword 'break'";
 
-    case 90/*TokenKind.CASE*/:
+    case 88/*TokenKind.CASE*/:
 
       return "keyword 'case'";
 
-    case 91/*TokenKind.CATCH*/:
+    case 89/*TokenKind.CATCH*/:
 
       return "keyword 'catch'";
 
-    case 92/*TokenKind.CONST*/:
+    case 91/*TokenKind.CONST*/:
 
       return "keyword 'const'";
 
-    case 93/*TokenKind.CONTINUE*/:
+    case 92/*TokenKind.CONTINUE*/:
 
       return "keyword 'continue'";
 
-    case 94/*TokenKind.DEFAULT*/:
+    case 93/*TokenKind.DEFAULT*/:
 
       return "keyword 'default'";
 
-    case 95/*TokenKind.DO*/:
+    case 94/*TokenKind.DO*/:
 
       return "keyword 'do'";
 
-    case 96/*TokenKind.ELSE*/:
+    case 95/*TokenKind.ELSE*/:
 
       return "keyword 'else'";
 
     case 97/*TokenKind.FALSE*/:
 
       return "keyword 'false'";
 
     case 98/*TokenKind.FINAL*/:
 
       return "keyword 'final'";
@@ skipping 66 matching lines @@
 
       return "keyword 'while'";
 
     default:
 
       return "TokenKind(" + kind.toString() + ")";
 
   }
 }
 TokenKind.isIdentifier = function(kind) {
-  return kind >= 70/*TokenKind.IDENTIFIER*/ && kind < 88/*TokenKind.AWAIT*/;
+  return kind >= 70/*TokenKind.IDENTIFIER*/ && kind < 86/*TokenKind.AWAIT*/;
 }
 TokenKind.infixPrecedence = function(kind) {
   switch (kind) {
     case 20/*TokenKind.ASSIGN*/:
 
       return 2;
 
     case 21/*TokenKind.ASSIGN_OR*/:
 
       return 2;
@@ skipping 371 matching lines @@
   this._peekToken = this.tokenizer.next();
   return this._previousToken;
 }
 Parser.prototype._peekKind = function(kind) {
   return this._peekToken.kind == kind;
 }
 Parser.prototype._peekIdentifier = function() {
   return this._isIdentifier(this._peekToken.kind);
 }
 Parser.prototype._isIdentifier = function(kind) {
-  return TokenKind.isIdentifier(kind) || (!this.get$enableAwait() && $eq(kind, 88/*TokenKind.AWAIT*/));
+  return TokenKind.isIdentifier(kind) || (!this.get$enableAwait() && $eq(kind, 86/*TokenKind.AWAIT*/));
 }
 Parser.prototype._maybeEat = function(kind) {
   if (this._peekToken.kind == kind) {
     this._previousToken = this._peekToken;
     this._peekToken = this.tokenizer.next();
     return true;
   }
   else {
     return false;
   }
@@ skipping 62 matching lines @@
 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));
 }
 Parser.prototype.topLevelDefinition = function() {
   switch (this._peek()) {
-    case 73/*TokenKind.CLASS*/:
+    case 90/*TokenKind.CLASS*/:
 
-      return this.classDefinition(73/*TokenKind.CLASS*/);
+      return this.classDefinition(90/*TokenKind.CLASS*/);
 
-    case 79/*TokenKind.INTERFACE*/:
+    case 77/*TokenKind.INTERFACE*/:
 
-      return this.classDefinition(79/*TokenKind.INTERFACE*/);
+      return this.classDefinition(77/*TokenKind.INTERFACE*/);
 
-    case 87/*TokenKind.TYPEDEF*/:
+    case 85/*TokenKind.TYPEDEF*/:
 
       return this.functionTypeAlias();
 
     default:
 
       return this.declaration(true);
 
   }
 }
 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(74/*TokenKind.EXTENDS*/)) {
+  if (this._maybeEat(96/*TokenKind.EXTENDS*/)) {
     _extends = this.typeList();
   }
   var _implements = null;
-  if (this._maybeEat(77/*TokenKind.IMPLEMENTS*/)) {
+  if (this._maybeEat(75/*TokenKind.IMPLEMENTS*/)) {
     _implements = this.typeList();
   }
   var _native = null;
-  if (this._maybeEat(81/*TokenKind.NATIVE*/)) {
+  if (this._maybeEat(79/*TokenKind.NATIVE*/)) {
     _native = this.maybeStringLiteral();
     if (_native != null) _native = new NativeType(_native);
   }
-  var oldFactory = this._maybeEat(75/*TokenKind.FACTORY*/);
+  var oldFactory = this._maybeEat(73/*TokenKind.FACTORY*/);
   var defaultType = null;
-  if (oldFactory || this._maybeEat(94/*TokenKind.DEFAULT*/)) {
+  if (oldFactory || this._maybeEat(93/*TokenKind.DEFAULT*/)) {
     if (oldFactory) {
       $globals.world.warning('factory no longer supported, use "default" instead', this._previousToken.get$span());
     }
     var baseType = this.nameTypeReference();
     var typeParams0 = null;
     if (this._peekKind(52/*TokenKind.LT*/)) {
       typeParams0 = this.typeParameters();
     }
     defaultType = new DefaultTypeReference(oldFactory, baseType, typeParams0, this._makeSpan(baseType.get$span().get$start()));
   }
   var body = [];
   if (this._maybeEat(6/*TokenKind.LBRACE*/)) {
     while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
       body.add$1(this.declaration(true));
       if (this._recover) {
         if (!this._recoverTo(7/*TokenKind.RBRACE*/, 10/*TokenKind.SEMICOLON*/)) break;
         this._maybeEat(10/*TokenKind.SEMICOLON*/);
       }
     }
   }
   else {
     this._errorExpected('block starting with "{" or ";"');
   }
-  return new TypeDefinition(kind == 73/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, defaultType, body, this._makeSpan(start));
+  return new TypeDefinition(kind == 90/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, defaultType, body, this._makeSpan(start));
 }
 Parser.prototype.functionTypeAlias = function() {
   var start = this._peekToken.start;
-  this._eat(87/*TokenKind.TYPEDEF*/);
+  this._eat(85/*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.get$type(), di.get$name(), formals, null, null, null, this._makeSpan(start));
   return new FunctionTypeDefinition(func, typeParams, this._makeSpan(start));
 }
@@ skipping 52 matching lines @@
 }
 Parser.prototype.finishDefinition = function(start, modifiers, di) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       var formals = this.formalParameterList();
       var inits = null, native_ = null;
       if (this._maybeEat(8/*TokenKind.COLON*/)) {
         inits = this.initializers();
       }
-      if (this._maybeEat(81/*TokenKind.NATIVE*/)) {
+      if (this._maybeEat(79/*TokenKind.NATIVE*/)) {
         native_ = this.maybeStringLiteral();
         if (native_ == null) native_ = '';
       }
       var body = this.functionBody(false);
       if (di.get$name() == null) {
         di.set$name(di.get$type().get$name());
       }
       return new FunctionDefinition(modifiers, di.get$type(), di.get$name(), formals, inits, native_, body, this._makeSpan(start));
 
     case 20/*TokenKind.ASSIGN*/:
 
       this._eat(20/*TokenKind.ASSIGN*/);
       var value = this.expression();
       return this.finishField(start, modifiers, di.get$type(), di.get$name(), value);
 
     case 11/*TokenKind.COMMA*/:
     case 10/*TokenKind.SEMICOLON*/:
 
       return this.finishField(start, modifiers, di.get$type(), di.get$name(), null);
 
     default:
 
       this._errorExpected('declaration');
       return null;
 
   }
 }
 Parser.prototype.declaration = function(includeOperators) {
   var start = this._peekToken.start;
-  if (this._peekKind(75/*TokenKind.FACTORY*/)) {
+  if (this._peekKind(73/*TokenKind.FACTORY*/)) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
   return this.finishDefinition(start, modifiers, this.declaredIdentifier(includeOperators));
 }
 Parser.prototype.factoryConstructorDeclaration = function() {
   var start = this._peekToken.start;
   var factoryToken = this._next();
   var names = [this.identifier()];
   while (this._maybeEat(14/*TokenKind.DOT*/)) {
@@ skipping 19 matching lines @@
   }
   if (names.get$length() > 1) {
     this._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);
 }
 Parser.prototype.statement = function() {
   switch (this._peek()) {
-    case 89/*TokenKind.BREAK*/:
+    case 87/*TokenKind.BREAK*/:
 
       return this.breakStatement();
 
-    case 93/*TokenKind.CONTINUE*/:
+    case 92/*TokenKind.CONTINUE*/:
 
       return this.continueStatement();
 
     case 106/*TokenKind.RETURN*/:
 
       return this.returnStatement();
 
     case 110/*TokenKind.THROW*/:
 
       return this.throwStatement();
 
     case 72/*TokenKind.ASSERT*/:
 
       return this.assertStatement();
 
     case 115/*TokenKind.WHILE*/:
 
       return this.whileStatement();
 
-    case 95/*TokenKind.DO*/:
+    case 94/*TokenKind.DO*/:
 
       return this.doStatement();
 
     case 100/*TokenKind.FOR*/:
 
       return this.forStatement();
 
     case 101/*TokenKind.IF*/:
 
       return this.ifStatement();
@@ skipping 89 matching lines @@
   var start = this._peekToken.start;
   this._eat(10/*TokenKind.SEMICOLON*/);
   return new EmptyStatement(this._makeSpan(start));
 }
 Parser.prototype.ifStatement = function() {
   var start = this._peekToken.start;
   this._eat(101/*TokenKind.IF*/);
   var test = this.testCondition();
   var trueBranch = this.statement();
   var falseBranch = null;
-  if (this._maybeEat(96/*TokenKind.ELSE*/)) {
+  if (this._maybeEat(95/*TokenKind.ELSE*/)) {
     falseBranch = this.statement();
   }
   return new IfStatement(test, trueBranch, falseBranch, this._makeSpan(start));
 }
 Parser.prototype.whileStatement = function() {
   var start = this._peekToken.start;
   this._eat(115/*TokenKind.WHILE*/);
   var test = this.testCondition();
   var body = this.statement();
   return new WhileStatement(test, body, this._makeSpan(start));
 }
 Parser.prototype.doStatement = function() {
   var start = this._peekToken.start;
-  this._eat(95/*TokenKind.DO*/);
+  this._eat(94/*TokenKind.DO*/);
   var body = this.statement();
   this._eat(115/*TokenKind.WHILE*/);
   var test = this.testCondition();
   this._eatSemicolon();
   return new DoStatement(body, test, this._makeSpan(start));
 }
 Parser.prototype.forStatement = function() {
   var start = this._peekToken.start;
   this._eat(100/*TokenKind.FOR*/);
   this._eatLeftParen();
@@ skipping 43 matching lines @@
   var expr = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   var body = this.statement();
   return new ForInStatement(di, expr, body, this._makeSpan(start));
 }
 Parser.prototype.tryStatement = function() {
   var start = this._peekToken.start;
   this._eat(112/*TokenKind.TRY*/);
   var body = this.block();
   var catches = [];
-  while (this._peekKind(91/*TokenKind.CATCH*/)) {
+  while (this._peekKind(89/*TokenKind.CATCH*/)) {
     catches.add$1(this.catchNode());
   }
   var finallyBlock = null;
   if (this._maybeEat(99/*TokenKind.FINALLY*/)) {
     finallyBlock = this.block();
   }
   return new TryStatement(body, catches, finallyBlock, this._makeSpan(start));
 }
 Parser.prototype.catchNode = function() {
   var start = this._peekToken.start;
-  this._eat(91/*TokenKind.CATCH*/);
+  this._eat(89/*TokenKind.CATCH*/);
   this._eatLeftParen();
   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));
 }
 Parser.prototype.switchStatement = function() {
   var start = this._peekToken.start;
   this._eat(108/*TokenKind.SWITCH*/);
   var test = this.testCondition();
   var cases = [];
   this._eat(6/*TokenKind.LBRACE*/);
   while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
     cases.add$1(this.caseNode());
   }
   return new SwitchStatement(test, cases, this._makeSpan(start));
 }
 Parser.prototype._peekCaseEnd = function() {
   var kind = this._peek();
-  return $eq(kind, 7/*TokenKind.RBRACE*/) || $eq(kind, 90/*TokenKind.CASE*/) || $eq(kind, 94/*TokenKind.DEFAULT*/);
+  return $eq(kind, 7/*TokenKind.RBRACE*/) || $eq(kind, 88/*TokenKind.CASE*/) || $eq(kind, 93/*TokenKind.DEFAULT*/);
 }
 Parser.prototype.caseNode = function() {
   var start = this._peekToken.start;
   var label = null;
   if (this._peekIdentifier()) {
     label = this.identifier();
     this._eat(8/*TokenKind.COLON*/);
   }
   var cases = [];
   while (true) {
-    if (this._maybeEat(90/*TokenKind.CASE*/)) {
+    if (this._maybeEat(88/*TokenKind.CASE*/)) {
       cases.add$1(this.expression());
       this._eat(8/*TokenKind.COLON*/);
     }
-    else if (this._maybeEat(94/*TokenKind.DEFAULT*/)) {
+    else if (this._maybeEat(93/*TokenKind.DEFAULT*/)) {
       cases.add$1();
       this._eat(8/*TokenKind.COLON*/);
     }
     else {
       break;
     }
   }
   if ($eq(cases.get$length(), 0)) {
     this._error('case or default');
   }
   var stmts = [];
   while (!this._peekCaseEnd()) {
     stmts.add$1(this.statement());
-    if (this._recover && !this._recoverTo(7/*TokenKind.RBRACE*/, 90/*TokenKind.CASE*/, 94/*TokenKind.DEFAULT*/)) {
+    if (this._recover && !this._recoverTo(7/*TokenKind.RBRACE*/, 88/*TokenKind.CASE*/, 93/*TokenKind.DEFAULT*/)) {
       break;
     }
   }
   return new CaseNode(label, cases, stmts, this._makeSpan(start));
 }
 Parser.prototype.returnStatement = function() {
   var start = this._peekToken.start;
   this._eat(106/*TokenKind.RETURN*/);
   var expr;
   if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
@@ skipping 22 matching lines @@
   var start = this._peekToken.start;
   this._eat(72/*TokenKind.ASSERT*/);
   this._eatLeftParen();
   var expr = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   this._eatSemicolon();
   return new AssertStatement(expr, this._makeSpan(start));
 }
 Parser.prototype.breakStatement = function() {
   var start = this._peekToken.start;
-  this._eat(89/*TokenKind.BREAK*/);
+  this._eat(87/*TokenKind.BREAK*/);
   var name = null;
   if (this._peekIdentifier()) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new BreakStatement(name, this._makeSpan(start));
 }
 Parser.prototype.continueStatement = function() {
   var start = this._peekToken.start;
-  this._eat(93/*TokenKind.CONTINUE*/);
+  this._eat(92/*TokenKind.CONTINUE*/);
   var name = null;
   if (this._peekIdentifier()) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new ContinueStatement(name, this._makeSpan(start));
 }
 Parser.prototype.expression = function() {
   return this.infixExpression(0);
 }
@@ skipping 99 matching lines @@
 
   }
 }
 Parser.prototype.unaryExpression = function() {
   var start = this._peekToken.start;
   if (this._isPrefixUnaryOperator(this._peek())) {
     var tok = this._next();
     var expr = this.unaryExpression();
     return new UnaryExpression(tok, expr, this._makeSpan(start));
   }
-  else if (this.get$enableAwait() && this._maybeEat(88/*TokenKind.AWAIT*/)) {
+  else if (this.get$enableAwait() && this._maybeEat(86/*TokenKind.AWAIT*/)) {
     var expr = this.unaryExpression();
     return new AwaitExpression(expr, this._makeSpan(start));
   }
   return this.finishPostfixExpression(this.primary());
 }
 Parser.prototype.argument = function() {
   var start = this._peekToken.start;
   var expr;
   var label = null;
   if (this._maybeEat(15/*TokenKind.ELLIPSIS*/)) {
@@ skipping 101 matching lines @@
     case 109/*TokenKind.THIS*/:
 
       this._eat(109/*TokenKind.THIS*/);
       return new ThisExpression(this._makeSpan(start));
 
     case 107/*TokenKind.SUPER*/:
 
       this._eat(107/*TokenKind.SUPER*/);
       return new SuperExpression(this._makeSpan(start));
 
-    case 92/*TokenKind.CONST*/:
+    case 91/*TokenKind.CONST*/:
 
-      this._eat(92/*TokenKind.CONST*/);
+      this._eat(91/*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 {
@@ skipping 210 matching lines @@
       name = this.identifier().get$name();
       break;
 
     case 109/*TokenKind.THIS*/:
 
       this._eat(109/*TokenKind.THIS*/);
       this._eat(14/*TokenKind.DOT*/);
       name = ('this.' + this.identifier().get$name());
       break;
 
-    case 76/*TokenKind.GET*/:
+    case 74/*TokenKind.GET*/:
 
       if (!includeOperators) return null;
-      this._eat(76/*TokenKind.GET*/);
+      this._eat(74/*TokenKind.GET*/);
       if (this._peekIdentifier()) {
         name = ('get:' + this.identifier().get$name());
       }
       else {
         name = 'get';
       }
       break;
 
-    case 84/*TokenKind.SET*/:
+    case 82/*TokenKind.SET*/:
 
       if (!includeOperators) return null;
-      this._eat(84/*TokenKind.SET*/);
+      this._eat(82/*TokenKind.SET*/);
       if (this._peekIdentifier()) {
         name = ('set:' + this.identifier().get$name());
       }
       else {
         name = 'set';
       }
       break;
 
-    case 83/*TokenKind.OPERATOR*/:
+    case 81/*TokenKind.OPERATOR*/:
 
       if (!includeOperators) return null;
-      this._eat(83/*TokenKind.OPERATOR*/);
+      this._eat(81/*TokenKind.OPERATOR*/);
       var kind = this._peek();
-      if ($eq(kind, 82/*TokenKind.NEGATE*/)) {
+      if ($eq(kind, 80/*TokenKind.NEGATE*/)) {
         name = ':negate';
         this._next();
       }
       else {
         name = TokenKind.binaryMethodName(kind);
         if (name == null) {
           name = 'operator';
         }
         else {
           this._next();
@@ skipping 118 matching lines @@
     return this.finishMapLiteral(start, isConst, genericType);
   }
   else {
     this._errorExpected('array or map literal');
   }
 }
 Parser.prototype._readModifiers = function() {
   var modifiers = null;
   while (true) {
     switch (this._peek()) {
-      case 86/*TokenKind.STATIC*/:
+      case 84/*TokenKind.STATIC*/:
       case 98/*TokenKind.FINAL*/:
-      case 92/*TokenKind.CONST*/:
+      case 91/*TokenKind.CONST*/:
       case 71/*TokenKind.ABSTRACT*/:
-      case 75/*TokenKind.FACTORY*/:
+      case 73/*TokenKind.FACTORY*/:
 
         if (modifiers == null) modifiers = [];
         modifiers.add$1(this._next());
         break;
 
       default:
 
         return modifiers;
 
     }
   }
   return null;
 }
 Parser.prototype.typeParameter = function() {
   var start = this._peekToken.start;
   var name = this.identifier();
   var myType = null;
-  if (this._maybeEat(74/*TokenKind.EXTENDS*/)) {
+  if (this._maybeEat(96/*TokenKind.EXTENDS*/)) {
     myType = this.type(1);
   }
   var tp = new TypeParameter(name, myType, this._makeSpan(start));
   return new ParameterType(name.get$name(), tp);
 }
 Parser.prototype.get$typeParameter = function() {
   return this.typeParameter.bind(this);
 }
 Parser.prototype.typeParameters = function() {
   this._eat(52/*TokenKind.LT*/);
@@ skipping 2070 matching lines @@
   if (methodName == null) methodName = definition.name.name;
   var method = new MethodMember(methodName, this, definition);
   if (method.get$isConstructor()) {
     if (this.constructors.containsKey(method.get$constructorName())) {
       $globals.world.error(('duplicate constructor definition of ' + method.get$name()), definition.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
   }
-  if (definition.modifiers != null && definition.modifiers.get$length() == 1 && $eq(definition.modifiers.$index(0).get$kind(), 75/*TokenKind.FACTORY*/)) {
+  if (definition.modifiers != null && definition.modifiers.get$length() == 1 && $eq(definition.modifiers.$index(0).get$kind(), 73/*TokenKind.FACTORY*/)) {
     if (this.factories.getFactory(method.get$constructorName(), method.get$name()) != null) {
       $globals.world.error(('duplicate factory definition of "' + method.get$name() + '"'), definition.span);
       return;
     }
     this.factories.addFactory(method.get$constructorName(), method.get$name(), method);
     return;
   }
   if (methodName.startsWith('get:') || methodName.startsWith('set:')) {
     var propName = methodName.substring(4);
     var prop = this.members.$index(propName);
@@ skipping 1741 matching lines @@
 }
 var const$0 = new EnvMap()/*const EnvMap()*/;
 var const$127 = new IllegalAccessException()/*const IllegalAccessException()*/;
 var const$128 = ImmutableList.ImmutableList$from$factory([])/*const []*/;
 var const$2 = new EmptyQueueException()/*const EmptyQueueException()*/;
 var const$3 = new _DeletedKeySentinel()/*const _DeletedKeySentinel()*/;
 var const$8 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 var $globals = {};
 $static_init();
 main();