When += (and similar operations) are converted to = + ,

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 644 matching lines @@
 ListFactory.prototype.sort$1 = function($0) {
   return this.sort(to$call$2($0));
 };
 ListFactory_E = ListFactory;
 ListFactory_K = ListFactory;
 ListFactory_String = ListFactory;
 ListFactory_V = ListFactory;
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
-  this._dart_coreimpl_pos = 0;
+  this._pos = 0;
   // Initializers done
 }
 ListIterator.prototype.hasNext = function() {
   return this._array.get$length() > this._dart_coreimpl_pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$8/*const NoMoreElementsException()*/);
   }
-  return this._array.$index(this._dart_coreimpl_pos++);
+  return this._array.$index(this._pos++);
 }
 ListIterator.prototype.hasNext$0 = ListIterator.prototype.hasNext;
 ListIterator.prototype.next$0 = ListIterator.prototype.next;
 // ********** Code for NumImplementation **************
 NumImplementation = Number;
 NumImplementation.prototype.isNaN = function() {
   return isNaN(this);
 }
 NumImplementation.prototype.isNegative = function() {
   return this == 0 ? (1 / this) < 0 : this < 0;
@@ skipping 2881 matching lines @@
     var name = TokenKind.binaryMethodName(node.op.kind);
     if (node.op.kind == 49/*TokenKind.NE*/) {
       name = ':ne';
     }
     if (name == null) {
       $globals.world.internalError(('unimplemented binary op ' + node.op), node.span);
       return;
     }
     return x.invoke$4(this, name, node, new Arguments(null, [y]));
   }
+  else if ((assignKind != 0) && ((node.y instanceof BinaryExpression))) {
+    return this._visitAssign(assignKind, node.x, new ParenExpression(node.y, node.y.span), node, to$call$1(null), isVoid);
+  }
   else {
     return this._visitAssign(assignKind, node.x, node.y, node, to$call$1(null), isVoid);
   }
 }
 MethodGenerator.prototype._visitAssign = function(kind, xn, yn, position, captureOriginal, isVoid) {
   if (captureOriginal == null) {
     captureOriginal = (function (x) {
       return x;
     })
     ;
@@ skipping 2930 matching lines @@
   return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c) || c == 36);
 }
 TokenizerHelpers.isInterpIdentifierPart = function(c) {
   return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c));
 }
 // ********** Code for TokenizerBase **************
 $inherits(TokenizerBase, TokenizerHelpers);
 function TokenizerBase(_source, _skipWhitespace, index) {
   this._source = _source;
   this._skipWhitespace = _skipWhitespace;
-  this._index = index;
+  this._lang_index = index;
   // Initializers done
   TokenizerHelpers.call(this);
   this._text = this._source.get$text();
 }
 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 Token(kind, this._source, this._startIndex, this._index);
+  return new Token(kind, this._source, this._startIndex, this._lang_index);
 }
 TokenizerBase.prototype._errorToken = function(message) {
-  return new ErrorToken(65/*TokenKind.ERROR*/, this._source, this._startIndex, this._index, message);
+  return new ErrorToken(65/*TokenKind.ERROR*/, this._source, this._startIndex, this._lang_index, message);
 }
 TokenizerBase.prototype.finishWhitespace = function() {
-  this._index--;
-  while (this._index < this._text.length) {
-    var ch = this._text.charCodeAt(this._index++);
+  this._lang_index--;
+  while (this._lang_index < this._text.length) {
+    var ch = this._text.charCodeAt(this._lang_index++);
     if (ch == 32 || ch == 9 || ch == 13) {
     }
     else if (ch == 10) {
       if (!this._skipWhitespace) {
         return this._finishToken(63/*TokenKind.WHITESPACE*/);
       }
     }
     else {
-      this._index--;
+      this._lang_index--;
       if (this._skipWhitespace) {
         return this.next();
       }
       else {
         return this._finishToken(63/*TokenKind.WHITESPACE*/);
       }
     }
   }
   return this._finishToken(1/*TokenKind.END_OF_FILE*/);
 }
@@ skipping 31 matching lines @@
         }
         else {
           return this._finishToken(64/*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_INTEGER*/);
 }
 TokenizerBase.prototype.finishNumber = function() {
   this.eatDigits();
   if (this._peekChar() == 46) {
     this._nextChar();
     if (TokenizerHelpers.isDigit(this._peekChar())) {
       this.eatDigits();
       return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
     }
     else {
-      this._index--;
+      this._lang_index--;
     }
   }
   return this.finishNumberExtra(60/*TokenKind.INTEGER*/);
 }
 TokenizerBase.prototype.finishNumberExtra = function(kind) {
   if (this._maybeEatChar(101) || this._maybeEatChar(69)) {
     kind = 62/*TokenKind.DOUBLE*/;
     this._maybeEatChar(45);
     this._maybeEatChar(43);
     this.eatDigits();
@@ skipping 113 matching lines @@
 TokenizerBase.prototype.eatEscapeSequence = function() {
   var hex;
   switch (this._nextChar()) {
     case 120:
 
       return this.maybeEatHexDigit() && this.maybeEatHexDigit();
 
     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;
         }
       }
 
     default:
 
       return true;
@@ skipping 10 matching lines @@
   else {
     return this._finishToken(14/*TokenKind.DOT*/);
   }
 }
 TokenizerBase.prototype.finishIdentifier = function(ch) {
   if (this._interpStack != null && this._interpStack.depth == -1) {
     this._interpStack.depth = 0;
     if (ch == 36) {
       return this._errorToken("illegal character after $ in string interpolation");
     }
-    while (this._index < this._text.length) {
-      if (!TokenizerHelpers.isInterpIdentifierPart(this._text.charCodeAt(this._index++))) {
-        this._index--;
+    while (this._lang_index < this._text.length) {
+      if (!TokenizerHelpers.isInterpIdentifierPart(this._text.charCodeAt(this._lang_index++))) {
+        this._lang_index--;
         break;
       }
     }
   }
   else {
-    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 (kind == 70/*TokenKind.IDENTIFIER*/) {
     return this._finishToken(70/*TokenKind.IDENTIFIER*/);
   }
   else {
     return this._finishToken(kind);
   }
 }
 TokenizerBase.prototype.next$0 = TokenizerBase.prototype.next;
 // ********** Code for Tokenizer **************
 $inherits(Tokenizer, TokenizerBase);
 function Tokenizer(source, skipWhitespace, index) {
   // Initializers done
   TokenizerBase.call(this, source, skipWhitespace, index);
 }
 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.get$isMultiline()) {
       return this.finishMultilineString(istack.get$quote());
     }
     else {
       return this.finishStringBody(istack.get$quote());
     }
   }
@@ skipping 314 matching lines @@
         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 95/*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) {
@@ skipping 998 matching lines @@
   this._afterParens = [];
 }
 Parser.prototype.get$enableAwait = function() {
   return $globals.experimentalAwaitPhase != null;
 }
 Parser.prototype.isPrematureEndOfFile = function() {
   if (this.throwOnIncomplete && this._maybeEat(1/*TokenKind.END_OF_FILE*/) || this._maybeEat(68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/) || this._maybeEat(69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/)) {
     $throw(new IncompleteSourceException(this._previousToken));
   }
   else if (this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
-    this._error('unexpected end of file', this._peekToken.get$span());
+    this._lang_error('unexpected end of file', this._peekToken.get$span());
     return true;
   }
   else {
     return false;
   }
 }
 Parser.prototype._recoverTo = function(kind1, kind2, kind3) {
   while (!this.isPrematureEndOfFile()) {
     var kind = this._peek();
     if (kind == kind1 || kind == kind2 || kind == kind3) {
       this._recover = false;
       return true;
     }
-    this._next();
+    this._lang_next();
   }
   return false;
 }
 Parser.prototype._peek = function() {
   return this._peekToken.kind;
 }
-Parser.prototype._next = function() {
+Parser.prototype._lang_next = function() {
   this._previousToken = this._peekToken;
   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);
 }
@@ skipping 14 matching lines @@
   if (!this._maybeEat(kind)) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
 }
 Parser.prototype._eatSemicolon = function() {
   if (this.optionalSemicolons && this._peekKind(1/*TokenKind.END_OF_FILE*/)) return;
   this._eat(10/*TokenKind.SEMICOLON*/);
 }
 Parser.prototype._errorExpected = function(expected) {
   if (this.throwOnIncomplete) this.isPrematureEndOfFile();
-  var tok = this._next();
+  var tok = this._lang_next();
   if ((tok instanceof ErrorToken) && tok.get$message() != null) {
-    this._error(tok.get$message(), tok.get$span());
+    this._lang_error(tok.get$message(), tok.get$span());
   }
   else {
-    this._error(('expected ' + expected + ', but found ' + tok), tok.get$span());
+    this._lang_error(('expected ' + expected + ', but found ' + tok), tok.get$span());
   }
 }
-Parser.prototype._error = function(message, location) {
+Parser.prototype._lang_error = function(message, location) {
   if (this._recover) return;
   if (location == null) {
     location = this._peekToken.get$span();
   }
   $globals.world.fatal(message, location);
   this._recover = true;
 }
 Parser.prototype._skipBlock = function() {
   var depth = 1;
   this._eat(6/*TokenKind.LBRACE*/);
   while (true) {
-    var tok = this._next();
+    var tok = this._lang_next();
     if ($eq(tok.get$kind(), 6/*TokenKind.LBRACE*/)) {
       depth += 1;
     }
     else if ($eq(tok.get$kind(), 7/*TokenKind.RBRACE*/)) {
       depth -= 1;
       if (depth == 0) return;
     }
     else if ($eq(tok.get$kind(), 1/*TokenKind.END_OF_FILE*/)) {
-      this._error('unexpected end of file during diet parse', tok.get$span());
+      this._lang_error('unexpected end of file during diet parse', tok.get$span());
       return;
     }
   }
 }
 Parser.prototype._makeSpan = function(start) {
   return new SourceSpan(this.source, start, this._previousToken.end);
 }
 Parser.prototype.compilationUnit = function() {
   var ret = [];
   this._maybeEat(13/*TokenKind.HASHBANG*/);
@@ skipping 120 matching lines @@
     }
     else {
       return this.block();
     }
   }
   else if (!inExpression) {
     if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
       return null;
     }
   }
-  this._error('Expected function body (neither { nor => found)');
+  this._lang_error('Expected function body (neither { nor => found)');
 }
 Parser.prototype.finishField = function(start, modifiers, typeParams, type, name, value) {
   if (typeParams != null) {
     $globals.world.internalError('trying to create a generic field', this._makeSpan(start));
   }
   var names = [name];
   var values = [value];
   while (this._maybeEat(11/*TokenKind.COMMA*/)) {
     names.add$1(this.identifier());
     if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
@@ skipping 46 matching lines @@
 Parser.prototype.declaration = function(includeOperators) {
   var start = this._peekToken.start;
   if (this._peekKind(75/*TokenKind.FACTORY*/)) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
   return this.finishDefinition(start, modifiers, this.declaredIdentifier(includeOperators), null);
 }
 Parser.prototype.factoryConstructorDeclaration = function() {
   var start = this._peekToken.start;
-  var factoryToken = this._next();
+  var factoryToken = this._lang_next();
   var names = [this.identifier()];
   while (this._maybeEat(14/*TokenKind.DOT*/)) {
     names.add$1(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.get$length() > 1) {
       name = names.removeLast$0();
     }
     else {
       name = new Identifier('', names.$index(0).get$span());
     }
   }
   else {
     name = new Identifier('', names.$index(0).get$span());
   }
   if (names.get$length() > 1) {
-    this._error('unsupported qualified name for factory', names.$index(0).get$span());
+    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, typeParams);
 }
 Parser.prototype.statement = function() {
   switch (this._peek()) {
     case 89/*TokenKind.BREAK*/:
 
       return this.breakStatement();
@@ skipping 258 matching lines @@
     }
     else if (this._maybeEat(94/*TokenKind.DEFAULT*/)) {
       cases.add$1();
       this._eat(8/*TokenKind.COLON*/);
     }
     else {
       break;
     }
   }
   if ($eq(cases.get$length(), 0)) {
-    this._error('case or default');
+    this._lang_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*/)) {
       break;
     }
   }
   return new CaseNode(label, cases, stmts, this._makeSpan(start));
 }
@@ skipping 64 matching lines @@
     if (type.get$names() == null) {
       type.set$names([expr.get$name()]);
     }
     else {
       type.get$names().add$1(expr.get$name());
     }
     type.set$span(expr.get$span());
     return type;
   }
   else {
-    this._error('expected type reference');
+    this._lang_error('expected type reference');
     return null;
   }
 }
 Parser.prototype.infixExpression = function(precedence) {
   return this.finishInfixExpression(this.unaryExpression(), precedence);
 }
 Parser.prototype._finishDeclaredId = function(type) {
   var name = this.identifier();
   return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan(type.get$span().get$start())));
 }
@@ skipping 25 matching lines @@
 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._next();
+      var op = this._lang_next();
       if ($eq(op.get$kind(), 103/*TokenKind.IS*/)) {
         var isTrue = !this._maybeEat(19/*TokenKind.NOT*/);
         var typeRef = this.type(0);
         x = new IsExpression(isTrue, x, typeRef, this._makeSpan(x.span.start));
         continue;
       }
       var y = this.infixExpression($eq(prec, 2) ? prec : prec + 1);
       if ($eq(op.get$kind(), 33/*TokenKind.CONDITIONAL*/)) {
         this._eat(8/*TokenKind.COLON*/);
         var z = this.infixExpression(prec);
@@ skipping 22 matching lines @@
 
     default:
 
       return false;
 
   }
 }
 Parser.prototype.unaryExpression = function() {
   var start = this._peekToken.start;
   if (this._isPrefixUnaryOperator(this._peek())) {
-    var tok = this._next();
+    var tok = this._lang_next();
     var expr = this.unaryExpression();
     return new UnaryExpression(tok, expr, this._makeSpan(start));
   }
   else if (this.get$enableAwait() && this._maybeEat(88/*TokenKind.AWAIT*/)) {
     var expr = this.unaryExpression();
     return new AwaitExpression(expr, this._makeSpan(start));
   }
   return this.finishPostfixExpression(this.primary());
 }
 Parser.prototype.argument = function() {
@@ skipping 44 matching lines @@
     case 14/*TokenKind.DOT*/:
 
       this._eat(14/*TokenKind.DOT*/);
       var name = this.identifier();
       var ret = new DotExpression(expr, name, this._makeSpan(expr.get$span().get$start()));
       return this.finishPostfixExpression(ret);
 
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
-      var tok = this._next();
+      var tok = this._lang_next();
       return new PostfixExpression(expr, tok, this._makeSpan(expr.get$span().get$start()));
 
     case 9/*TokenKind.ARROW*/:
     case 6/*TokenKind.LBRACE*/:
 
       return expr;
 
     default:
 
       if (this._peekIdentifier()) {
         return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan(expr.get$span().get$start())));
       }
       else {
         return expr;
       }
 
   }
 }
 Parser.prototype.finishCallOrLambdaExpression = function(expr) {
   if (this._atClosureParameters()) {
     var formals = this.formalParameterList();
     var body = this.functionBody(true);
     return this._makeFunction(expr, formals, body);
   }
   else {
     if ((expr instanceof DeclaredIdentifier)) {
-      this._error('illegal target for call, did you mean to declare a function?', expr.get$span());
+      this._lang_error('illegal target for call, did you mean to declare a function?', expr.get$span());
     }
     var args = this.arguments();
     return this.finishPostfixExpression(new CallExpression(expr, args, this._makeSpan(expr.get$span().get$start())));
   }
 }
 Parser.prototype._isBin = function(expr, kind) {
   return (expr instanceof BinaryExpression) && $eq(expr.get$op().get$kind(), kind);
 }
 Parser.prototype._boolTypeRef = function(span) {
   return new TypeReference(span, $globals.world.nonNullBool);
@@ skipping 64 matching lines @@
       this._eat(111/*TokenKind.TRUE*/);
       return new LiteralExpression(true, this._boolTypeRef(this._makeSpan(start)), 'true', this._makeSpan(start));
 
     case 97/*TokenKind.FALSE*/:
 
       this._eat(97/*TokenKind.FALSE*/);
       return new LiteralExpression(false, this._boolTypeRef(this._makeSpan(start)), 'false', this._makeSpan(start));
 
     case 61/*TokenKind.HEX_INTEGER*/:
 
-      var t = this._next();
+      var t = this._lang_next();
       return new LiteralExpression(Parser.parseHex(t.get$text().substring$1(2)), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 60/*TokenKind.INTEGER*/:
 
-      var t = this._next();
+      var t = this._lang_next();
       return new LiteralExpression(Math.parseInt(t.get$text()), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 62/*TokenKind.DOUBLE*/:
 
-      var t = this._next();
+      var t = this._lang_next();
       return new LiteralExpression(Math.parseDouble(t.get$text()), this._doubleTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 58/*TokenKind.STRING*/:
 
       return this.stringLiteralExpr();
 
     case 66/*TokenKind.INCOMPLETE_STRING*/:
 
       return this.stringInterpolation();
 
@@ skipping 14 matching lines @@
       }
       return new VarExpression(this.identifier(), this._makeSpan(start));
 
   }
 }
 Parser.prototype.stringInterpolation = function() {
   var start = this._peekToken.start;
   var lits = [];
   var startQuote = null, endQuote = null;
   while (this._peekKind(66/*TokenKind.INCOMPLETE_STRING*/)) {
-    var token = this._next();
+    var token = this._lang_next();
     var text = token.get$text();
     if (startQuote == null) {
       if (isMultilineString(text)) {
         endQuote = text.substring$2(0, 3);
         startQuote = endQuote + '\n';
       }
       else {
         startQuote = endQuote = text.$index(0);
       }
       text = text.substring$2(0, text.get$length() - 1) + endQuote;
     }
     else {
       text = startQuote + text.substring$2(0, text.get$length() - 1) + endQuote;
     }
     lits.add$1(this.makeStringLiteral(text, token.get$span()));
     if (this._maybeEat(6/*TokenKind.LBRACE*/)) {
       lits.add$1(this.expression());
       this._eat(7/*TokenKind.RBRACE*/);
     }
     else if (this._maybeEat(109/*TokenKind.THIS*/)) {
       lits.add$1(new ThisExpression(this._previousToken.get$span()));
     }
     else {
       var id = this.identifier();
       lits.add$1(new VarExpression(id, id.get$span()));
     }
   }
-  var tok = this._next();
+  var tok = this._lang_next();
   if ($ne(tok.get$kind(), 58/*TokenKind.STRING*/)) {
     this._errorExpected('interpolated string');
   }
   var text = startQuote + tok.get$text();
   lits.add$1(this.makeStringLiteral(text, tok.get$span()));
   var span = this._makeSpan(start);
   return new LiteralExpression(lits, this._stringTypeRef(span), '\$\$\$', span);
 }
 Parser.prototype.makeStringLiteral = function(text, span) {
   return new LiteralExpression(text, this._stringTypeRef(span), text, span);
 }
 Parser.prototype.stringLiteralExpr = function() {
-  var token = this._next();
+  var token = this._lang_next();
   return this.makeStringLiteral(token.get$text(), token.get$span());
 }
 Parser.prototype.maybeStringLiteral = function() {
   var kind = this._peek();
   if ($eq(kind, 58/*TokenKind.STRING*/)) {
-    return parseStringLiteral(this._next().get$text());
+    return parseStringLiteral(this._lang_next().get$text());
   }
   else if ($eq(kind, 59/*TokenKind.STRING_PART*/)) {
-    this._next();
+    this._lang_next();
     this._errorExpected('string literal, but found interpolated string start');
   }
   else if ($eq(kind, 66/*TokenKind.INCOMPLETE_STRING*/)) {
-    this._next();
+    this._lang_next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
 Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
   if (this._atClosureParameters()) {
     var formals = this.formalParameterList();
     var body = this.functionBody(true);
     var func = new FunctionDefinition(null, null, null, formals, null, null, null, body, this._makeSpan(start));
@@ skipping 17 matching lines @@
 Parser.prototype._eatLeftParen = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   this._afterParensIndex++;
 }
 Parser.prototype._peekAfterCloseParen = function() {
   if (this._afterParensIndex < this._afterParens.get$length()) {
     return this._afterParens.$index(this._afterParensIndex);
   }
   this._afterParensIndex = 0;
   this._afterParens.clear();
-  var tokens = [this._next()];
+  var tokens = [this._lang_next()];
   this._lookaheadAfterParens(tokens);
   var after = this._peekToken;
   tokens.add$1(after);
   this.tokenizer = new DivertedTokenSource(tokens, this, this.tokenizer);
-  this._next();
+  this._lang_next();
   return after;
 }
 Parser.prototype._lookaheadAfterParens = function(tokens) {
   var saved = this._afterParens.get$length();
   this._afterParens.add(null);
   while (true) {
-    var token = this._next();
+    var token = this._lang_next();
     tokens.add(token);
     var kind = token.kind;
     if (kind == 3/*TokenKind.RPAREN*/ || kind == 1/*TokenKind.END_OF_FILE*/) {
       this._afterParens.$setindex(saved, this._peekToken);
       return;
     }
     else if (kind == 2/*TokenKind.LPAREN*/) {
       this._lookaheadAfterParens(tokens);
     }
   }
 }
 Parser.prototype._typeAsIdentifier = function(type) {
   return type.get$name();
 }
 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._error('rest no longer supported', this._previousToken.get$span());
+      this._lang_error('rest no longer supported', this._previousToken.get$span());
       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;
 
@@ skipping 21 matching lines @@
       }
       break;
 
     case 83/*TokenKind.OPERATOR*/:
 
       if (!includeOperators) return null;
       this._eat(83/*TokenKind.OPERATOR*/);
       var kind = this._peek();
       if ($eq(kind, 82/*TokenKind.NEGATE*/)) {
         name = ':negate';
-        this._next();
+        this._lang_next();
       }
       else {
         name = TokenKind.binaryMethodName(kind);
         if (name == null) {
           name = 'operator';
         }
         else {
-          this._next();
+          this._lang_next();
         }
       }
       break;
 
     default:
 
       return null;
 
   }
   return new Identifier(name, this._makeSpan(start));
@@ skipping 115 matching lines @@
   var modifiers = null;
   while (true) {
     switch (this._peek()) {
       case 86/*TokenKind.STATIC*/:
       case 98/*TokenKind.FINAL*/:
       case 92/*TokenKind.CONST*/:
       case 71/*TokenKind.ABSTRACT*/:
       case 75/*TokenKind.FACTORY*/:
 
         if (modifiers == null) modifiers = [];
-        modifiers.add$1(this._next());
+        modifiers.add$1(this._lang_next());
         break;
 
       default:
 
         return modifiers;
 
     }
   }
   return null;
 }
@@ skipping 80 matching lines @@
 }
 Parser.prototype.nameTypeReference = function() {
   var start = this._peekToken.start;
   var name;
   var names = null;
   var typeArgs = null;
   var isFinal = false;
   switch (this._peek()) {
     case 114/*TokenKind.VOID*/:
 
-      return new TypeReference(this._next().get$span(), $globals.world.voidType);
+      return new TypeReference(this._lang_next().get$span(), $globals.world.voidType);
 
     case 113/*TokenKind.VAR*/:
 
-      return new TypeReference(this._next().get$span(), $globals.world.varType);
+      return new TypeReference(this._lang_next().get$span(), $globals.world.varType);
 
     case 98/*TokenKind.FINAL*/:
 
       this._eat(98/*TokenKind.FINAL*/);
       isFinal = true;
       name = this.identifier();
       break;
 
     default:
 
@@ skipping 23 matching lines @@
 Parser.prototype.formalParameter = function(inOptionalBlock) {
   var start = this._peekToken.start;
   var isThis = false;
   var isRest = false;
   var di = this.declaredIdentifier(false);
   var type = di.get$type();
   var name = di.get$name();
   var value = null;
   if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
     if (!inOptionalBlock) {
-      this._error('default values only allowed inside [optional] section');
+      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, 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));
 }
 Parser.prototype.formalParameterList = function() {
   this._eatLeftParen();
   var formals = [];
   var inOptionalBlock = false;
   if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
     if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
       inOptionalBlock = true;
     }
     formals.add$1(this.formalParameter(inOptionalBlock));
     while (this._maybeEat(11/*TokenKind.COMMA*/)) {
       if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
         if (inOptionalBlock) {
-          this._error('already inside an optional block', this._previousToken.get$span());
+          this._lang_error('already inside an optional block', this._previousToken.get$span());
         }
         inOptionalBlock = true;
       }
       formals.add$1(this.formalParameter(inOptionalBlock));
     }
     if (inOptionalBlock) {
       this._eat(5/*TokenKind.RBRACK*/);
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return formals;
 }
 Parser.prototype.identifier = function() {
-  var tok = this._next();
+  var tok = this._lang_next();
   if (!this._isIdentifier(tok.get$kind())) {
-    this._error(('expected identifier, but found ' + tok), tok.get$span());
+    this._lang_error(('expected identifier, but found ' + tok), tok.get$span());
   }
   return new Identifier(tok.get$text(), this._makeSpan(tok.get$start()));
 }
 Parser.prototype._makeFunction = function(expr, formals, body) {
   var name, type;
   if ((expr instanceof VarExpression)) {
     name = expr.get$name();
     type = null;
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     name = expr.get$name();
     type = expr.get$type();
   }
   else {
-    this._error('bad function body', expr.get$span());
+    this._lang_error('bad function body', expr.get$span());
   }
   var span = new SourceSpan(expr.get$span().get$file(), expr.get$span().get$start(), body.get$span().get$end());
   var func = new FunctionDefinition(null, type, name, formals, null, null, null, body, span);
   return new LambdaExpression(func, func.get$span());
 }
 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._error('expected declared identifier');
+    this._lang_error('expected declared identifier');
     return new DeclaredIdentifier(null, null, e.get$span());
   }
 }
 Parser.prototype._makeLabel = function(expr) {
   if ((expr instanceof VarExpression)) {
     return expr.get$name();
   }
   else {
     this._errorExpected('label');
     return null;
   }
 }
 Parser.prototype.block$0 = Parser.prototype.block;
 // ********** Code for IncompleteSourceException **************
 function IncompleteSourceException(token) {
   this.token = token;
   // Initializers done
 }
 IncompleteSourceException.prototype.toString = function() {
   if (this.token.get$span() == null) return ('Unexpected ' + this.token);
   return this.token.get$span().toMessageString(('Unexpected ' + this.token));
 }
 IncompleteSourceException.prototype.toString$0 = IncompleteSourceException.prototype.toString;
 // ********** Code for DivertedTokenSource **************
 function DivertedTokenSource(tokens, parser, previousTokenizer) {
-  this._pos = 0
+  this._lang_pos = 0
   this.tokens = tokens;
   this.parser = parser;
   this.previousTokenizer = previousTokenizer;
   // Initializers done
 }
 DivertedTokenSource.prototype.next = function() {
   var token = this.tokens.$index(this._pos);
   ++this._pos;
   if (this._pos == this.tokens.get$length()) {
     this.parser.tokenizer = this.previousTokenizer;
@@ skipping 2633 matching lines @@
   }
   member = this.home.get$library().lookup(name, this.span);
   if (member != null) {
     return member;
   }
   this._ensureCode();
   return null;
 }
 // ********** 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);
   }
 }
 CompilerException.prototype.toString$0 = CompilerException.prototype.toString;
 // ********** Code for World **************
 function World(files) {
   this.errors = 0
   this.warnings = 0
   this.dartBytesRead = 0
   this.jsBytesWritten = 0
   this.seenFatal = false
@@ skipping 861 matching lines @@
   $globals._NO_COLOR = '\u001b[0m';
   $globals._RED_COLOR = '\u001b[31m';
 }
 var const$0 = new EnvMap()/*const EnvMap()*/;
 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();