Roll DOM APIs forward on IDL & update Frog DOM

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 2229 matching lines @@
 }
 Collections.filter = function(source, destination, f) {
   for (var $i = source.iterator(); $i.hasNext$0(); ) {
     var e = $i.next$0();
     if (f(e)) destination.add(e);
   }
   return destination;
 }
 // ********** Code for DateImplementation **************
 function DateImplementation() {}
+DateImplementation.fromEpoch$ctor = function(value, timeZone) {
+  this.value = value;
+  this.timeZone = timeZone;
+  // Initializers done
+}
+DateImplementation.fromEpoch$ctor.prototype = DateImplementation.prototype;
 DateImplementation.now$ctor = function() {
   this.timeZone = new TimeZoneImplementation.local$ctor();
   this.value = DateImplementation._now();
   // Initializers done
   this._asJs();
 }
 DateImplementation.now$ctor.prototype = DateImplementation.prototype;
-DateImplementation.fromEpoch$ctor = function(value, timeZone) {
-  this.value = value;
-  this.timeZone = timeZone;
-  // Initializers done
-}
-DateImplementation.fromEpoch$ctor.prototype = DateImplementation.prototype;
 DateImplementation.prototype.is$Date = function(){return this;};
 DateImplementation.prototype.is$Comparable = function(){return this;};
 DateImplementation.prototype.get$value = function() { return this.value; };
 DateImplementation.prototype.$eq = function(other) {
   if (!((other instanceof DateImplementation))) return false;
   return (this.value == other.get$value()) && ($eq(this.timeZone, other.timeZone));
 }
 DateImplementation.prototype.compareTo = function(other) {
   var $0;
   return $assert_num(this.value.compareTo$1(other.value));
@@ skipping 363 matching lines @@
 // ********** Code for top level **************
 //  ********** Library util **************
 // ********** Code for top level **************
 //  ********** Library scanner_implementation **************
 // ********** Code for ArrayBasedScanner **************
 function ArrayBasedScanner() {
   this.groupingStack = const$14/*const EmptyLink()*/
   this.extraCharOffset = 0;
   this.tokenStart = -1;
   this.byteOffset = -1;
-  this.tokens = new scanner_Token(0/*null.EOF_TOKEN*/, -1);
+  this.tokens = new Token(0/*null.EOF_TOKEN*/, -1);
   // Initializers done
   AbstractScanner$S.call(this);
   this.tail = this.tokens;
 }
 $inherits(ArrayBasedScanner, AbstractScanner$S);
 ArrayBasedScanner.prototype.get$charOffset = function() {
   return this.byteOffset + this.extraCharOffset;
 }
 ArrayBasedScanner.prototype.get$tail = function() { return this.tail; };
 ArrayBasedScanner.prototype.set$tail = function(value) { return this.tail = value; };
@@ skipping 16 matching lines @@
 }
 ArrayBasedScanner.prototype.appendStringToken = function(kind, value) {
   this.tail.next = new StringToken(kind, value, this.tokenStart);
   this.tail = this.tail.next;
 }
 ArrayBasedScanner.prototype.appendKeywordToken = function(keyword) {
   this.tail.next = new KeywordToken(keyword, this.tokenStart);
   this.tail = this.tail.next;
 }
 ArrayBasedScanner.prototype.appendEofToken = function() {
-  this.tail.next = new scanner_Token(0/*null.EOF_TOKEN*/, this.get$charOffset());
+  this.tail.next = new Token(0/*null.EOF_TOKEN*/, this.get$charOffset());
   this.tail = this.tail.next;
 }
 ArrayBasedScanner.prototype.beginToken = function() {
   this.tokenStart = this.get$charOffset();
 }
 ArrayBasedScanner.prototype.firstToken = function() {
   return this.tokens.next;
 }
 ArrayBasedScanner.prototype.addToCharOffset = function(offset) {
   this.extraCharOffset += offset;
@@ skipping 60 matching lines @@
     this.groupingStack.get$head().endGroup = oldTail.next;
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
 }
 // ********** Code for ArrayBasedScanner$SourceString **************
 function ArrayBasedScanner$SourceString() {
   this.groupingStack = const$14/*const EmptyLink()*/
   this.extraCharOffset = 0;
   this.tokenStart = -1;
   this.byteOffset = -1;
-  this.tokens = new scanner_Token(0/*null.EOF_TOKEN*/, -1);
+  this.tokens = new Token(0/*null.EOF_TOKEN*/, -1);
   // Initializers done
   AbstractScanner$S.call(this);
   this.tail = this.tokens;
 }
 $inherits(ArrayBasedScanner$SourceString, ArrayBasedScanner);
 // ********** Code for top level **************
 //  ********** Library scanner **************
 // ********** Code for AbstractScanner **************
 function AbstractScanner() {
   // Initializers done
@@ skipping 1202 matching lines @@
 // ********** Code for PartialParser **************
 function PartialParser(listener) {
   var $this = this; // closure support
   this.listener = listener;
   // Initializers done
   this.beginTypeArguments = (function (t) {
     return $this.listener.beginTypeArguments$1(t);
   })
   ;
   this.parseTypeFunction = (function (t) {
-    return $this.parseType((t && t.is$scanner_Token()));
+    return $this.parseType((t && t.is$Token()));
   })
   ;
   this.endTypeArguments = (function (c, bt, et) {
     return $this.listener.endTypeArguments$3(c, bt, et);
   })
   ;
   this.handleNoTypeArguments = (function (t) {
     return $this.listener.handleNoTypeArguments$1(t);
   })
   ;
   this.beginTypeVariables = (function (t) {
     return $this.listener.beginTypeVariables$1(t);
   })
   ;
   this.parseTypeVariableFunction = (function (t) {
-    return $this.parseTypeVariable((t && t.is$scanner_Token()));
+    return $this.parseTypeVariable((t && t.is$Token()));
   })
   ;
   this.endTypeVariables = (function (c, bt, et) {
     return $this.listener.endTypeVariables$3(c, bt, et);
   })
   ;
   this.handleNoTypeVariables = (function (t) {
     return $this.listener.handleNoTypeVariables$1(t);
   })
   ;
@@ skipping 183 matching lines @@
     return this.parseString(this.next(token));
   }
   return token;
 }
 PartialParser.prototype.parseString = function(token) {
   var $0;
   if (token.kind === 39/*null.STRING_TOKEN*/) {
     return this.next(token);
   }
   else {
-    return (($0 = this.listener.expected$2('string', token)) && $0.is$scanner_Token());
+    return (($0 = this.listener.expected$2('string', token)) && $0.is$Token());
   }
 }
 PartialParser.prototype.parseIdentifier = function(token) {
   if ($notnull_bool(this.isIdentifier(token))) {
     this.listener.handleIdentifier$1(token);
   }
   else {
     this.listener.expectedIdentifier$1(token);
   }
   return this.next(token);
@@ skipping 64 matching lines @@
   this.listener.handleNoTypeVariables$1(token);
   return token;
 }
 PartialParser.prototype.parseStuff = function(token, beginStuff, stuffParser, endStuff, handleNoStuff) {
   var $0;
   if ($notnull_bool(this.optional('<', token))) {
     var begin = token;
     beginStuff.call$1(begin);
     var count = 0;
     do {
-      token = (($0 = stuffParser.call$1(this.next(token))) && $0.is$scanner_Token());
+      token = (($0 = stuffParser.call$1(this.next(token))) && $0.is$Token());
       ++count;
     }
     while ($notnull_bool(this.optional(',', token)))
     endStuff.call$3(count, begin, token);
     return this.expect('>', token);
   }
   handleNoStuff.call$1(token);
   return token;
 }
 PartialParser.prototype.parseClassBody = function(token) {
@@ skipping 76 matching lines @@
 PartialParser.prototype.endTypeVariables$3 = function($0, $1, $2) {
   return this.endTypeVariables.call$3($0, $1, $2);
 };
 PartialParser.prototype.handleNoTypeArguments$1 = function($0) {
   return this.handleNoTypeArguments.call$1($0);
 };
 PartialParser.prototype.handleNoTypeVariables$1 = function($0) {
   return this.handleNoTypeVariables.call$1($0);
 };
 PartialParser.prototype.parseClass$1 = function($0) {
-  return this.parseClass(($0 && $0.is$scanner_Token()));
+  return this.parseClass(($0 && $0.is$Token()));
 };
-// ********** Code for scanner_Parser **************
-function scanner_Parser(listener) {
+// ********** Code for Parser **************
+function Parser(listener) {
   // Initializers done
   PartialParser.call(this, listener);
 }
-$inherits(scanner_Parser, PartialParser);
-scanner_Parser.prototype.parseFunction = function(token) {
+$inherits(Parser, PartialParser);
+Parser.prototype.parseFunction = function(token) {
   this.listener.beginFunction$1(token);
   token = this.parseReturnTypeOpt(token);
   this.listener.beginFunctionName$1(token);
   token = this.parseIdentifier(token);
   this.listener.endFunctionName$1(token);
   token = this.parseFormalParameters(token);
   return this.parseFunctionBody(token);
 }
-scanner_Parser.prototype.parseFunctionBody = function(token) {
+Parser.prototype.parseFunctionBody = function(token) {
   if ($notnull_bool(this.optional(';', token))) {
     this.listener.endFunctionBody$3(0, null, token);
     return token.next;
   }
   var begin = token;
   var statementCount = 0;
   this.listener.beginFunctionBody$1(begin);
   token = this.checkEof(this.expect('{', token));
   while (!$notnull_bool(this.optional('}', token))) {
     token = this.parseStatement(token);
     ++statementCount;
   }
   this.listener.endFunctionBody$3(statementCount, begin, token);
   return this.expect('}', token);
 }
-scanner_Parser.prototype.parseStatement = function(token) {
+Parser.prototype.parseStatement = function(token) {
   this.checkEof(token);
   var value = token.get$stringValue();
   switch (true) {
     case token.kind === 97/*null.IDENTIFIER_TOKEN*/:
 
       return this.parseExpressionStatementOrDeclaration(token);
 
     case value === '{':
 
       return this.parseBlock(token);
@@ skipping 17 matching lines @@
     case value === 'throw':
 
       return this.parseThrowStatement(token);
 
     default:
 
       return this.parseExpressionStatement(token);
 
   }
 }
-scanner_Parser.prototype.expectSemicolon = function(token) {
+Parser.prototype.expectSemicolon = function(token) {
   return this.expect(';', token);
 }
-scanner_Parser.prototype.parseReturnStatement = function(token) {
+Parser.prototype.parseReturnStatement = function(token) {
   var begin = token;
   this.listener.beginReturnStatement$1(begin);
   $assert('return' === token.get$stringValue(), "'return' === token.stringValue", "parser.dart", 455, 12);
   token = this.next(token);
   if ($notnull_bool(this.optional(';', token))) {
     this.listener.endReturnStatement$3(false, begin, token);
   }
   else {
     token = this.parseExpression(token);
     this.listener.endReturnStatement$3(true, begin, token);
   }
   return this.expectSemicolon(token);
 }
-scanner_Parser.prototype.peekAfterType = function(token) {
+Parser.prototype.peekAfterType = function(token) {
   $assert(token.kind === 97/*null.IDENTIFIER_TOKEN*/, "token.kind === IDENTIFIER_TOKEN", "parser.dart", 468, 12);
   var peek = token.next;
   if (peek.kind === 46/*null.PERIOD_TOKEN*/) {
     if (peek.next.kind === 97/*null.IDENTIFIER_TOKEN*/) {
       peek = peek.next.next;
     }
   }
   if (peek.kind === 60/*null.LT_TOKEN*/) {
     var beginGroupToken = (peek && peek.is$BeginGroupToken());
     var gtToken = beginGroupToken.endGroup;
     if (gtToken != null) {
       return gtToken.next;
     }
   }
   return peek;
 }
-scanner_Parser.prototype.peekIdentifierAfterType = function(token) {
+Parser.prototype.peekIdentifierAfterType = function(token) {
   var peek = this.peekAfterType(token);
   if (peek != null && peek.kind === 97/*null.IDENTIFIER_TOKEN*/) {
     return peek;
   }
   else {
     return null;
   }
 }
-scanner_Parser.prototype.parseExpressionStatementOrDeclaration = function(token) {
+Parser.prototype.parseExpressionStatementOrDeclaration = function(token) {
   var identifier = this.peekIdentifierAfterType(token);
   if (identifier != null) {
     $assert(identifier.kind === 97/*null.IDENTIFIER_TOKEN*/, "identifier.kind === IDENTIFIER_TOKEN", "parser.dart", 504, 14);
     var afterId = identifier.next;
     var afterIdKind = afterId.kind;
     if (afterIdKind === 61/*null.EQ_TOKEN*/ || afterIdKind === 59/*null.SEMICOLON_TOKEN*/) {
       return this.parseVariablesDeclaration(token);
     }
     else if (afterIdKind === 41/*null.RPAREN_TOKEN*/) {
       var beginParen = (afterId && afterId.is$BeginGroupToken());
       var endParen = beginParen.endGroup;
       var afterParens = endParen.next;
       if ($notnull_bool(this.optional('{', afterParens)) || $notnull_bool(this.optional('=>', afterParens))) {
         return this.parseFunction(token);
       }
     }
   }
   return this.parseExpressionStatement(token);
 }
-scanner_Parser.prototype.parseExpressionStatement = function(token) {
+Parser.prototype.parseExpressionStatement = function(token) {
   this.listener.beginExpressionStatement$1(token);
   token = this.parseExpression(token);
   this.listener.endExpressionStatement$1(token);
   return this.expectSemicolon(token);
 }
-scanner_Parser.prototype.parseExpression = function(token) {
+Parser.prototype.parseExpression = function(token) {
   token = this.parseConditionalExpression(token);
   if ($notnull_bool(this.isAssignmentOperator(token))) {
     var operator = token;
     token = this.parseExpression(this.next(token));
     this.listener.handleAssignmentExpression$1(operator);
   }
   return token;
 }
-scanner_Parser.prototype.isAssignmentOperator = function(token) {
+Parser.prototype.isAssignmentOperator = function(token) {
   return 2 === this.getPrecedence(token);
 }
-scanner_Parser.prototype.parseConditionalExpression = function(token) {
+Parser.prototype.parseConditionalExpression = function(token) {
   token = this.parseBinaryExpression(token, 4);
   if ($notnull_bool(this.optional('?', token))) {
     var question = token;
     token = this.parseExpression(this.next(token));
     var colon = token;
     token = this.expect(':', token);
     token = this.parseExpression(token);
     this.listener.handleConditionalExpression$2(question, colon);
   }
   return token;
 }
-scanner_Parser.prototype.parseBinaryExpression = function(token, precedence) {
+Parser.prototype.parseBinaryExpression = function(token, precedence) {
   $assert(precedence >= 4, "precedence >= 4", "parser.dart", 561, 12);
   token = this.parseUnaryExpression(token);
   var tokenLevel = this.getPrecedence(token);
   for (var level = $assert_num(tokenLevel);
    level >= precedence; --level) {
     while (tokenLevel === level) {
       var operator = token;
       token = this.parseBinaryExpression(this.next(token), level + 1);
       this.listener.handleBinaryExpression$1(operator);
       tokenLevel = this.getPrecedence(token);
     }
   }
   return token;
 }
-scanner_Parser.prototype.getPrecedence = function(token) {
+Parser.prototype.getPrecedence = function(token) {
   if (token == null) return 0;
   var value = token.get$stringValue();
   if (value == null) return 0;
   switch (true) {
     case value === '(':
 
       return 0;
 
     case value === '+':
 
@@ skipping 150 matching lines @@
     case value === '~/':
 
       return 13;
 
     default:
 
       return 0;
 
   }
 }
-scanner_Parser.prototype.parseUnaryExpression = function(token) {
+Parser.prototype.parseUnaryExpression = function(token) {
   var value = token.get$stringValue();
   switch (true) {
     case value === '!':
     case value === '+':
     case value === '-':
     case value === '++':
     case value === '--':
     case value === '~':
 
       {
@@ skipping 15 matching lines @@
           this.listener.handleUnaryPostfixExpression$1(token);
           token = this.next(token);
           break;
 
       }
       break;
 
   }
   return token;
 }
-scanner_Parser.prototype.parsePrimary = function(token) {
+Parser.prototype.parsePrimary = function(token) {
   var kind = token.kind;
   switch (true) {
     case kind === 97/*null.IDENTIFIER_TOKEN*/:
 
       return this.parseSend(token);
 
     case kind === 105/*null.INT_TOKEN*/:
 
       return this.parseLiteralInt(token);
 
@@ skipping 24 matching lines @@
       }
       $throw(new FallThroughError());
 
     default:
 
       this.listener.unexpected$1(token);
       $throw('not yet implemented');
 
   }
 }
-scanner_Parser.prototype.parseLiteralInt = function(token) {
+Parser.prototype.parseLiteralInt = function(token) {
   this.listener.handleLiteralInt$1(token);
   return token.next;
 }
-scanner_Parser.prototype.parseLiteralDouble = function(token) {
+Parser.prototype.parseLiteralDouble = function(token) {
   this.listener.handleLiteralDouble$1(token);
   return token.next;
 }
-scanner_Parser.prototype.parseLiteralString = function(token) {
+Parser.prototype.parseLiteralString = function(token) {
   this.listener.handleLiteralString$1(token);
   return token.next;
 }
-scanner_Parser.prototype.parseLiteralBool = function(token) {
+Parser.prototype.parseLiteralBool = function(token) {
   this.listener.handleLiteralBool$1(token);
   return token.next;
 }
-scanner_Parser.prototype.parseSend = function(token) {
+Parser.prototype.parseSend = function(token) {
   this.listener.beginSend$1(token);
   token = this.parseIdentifier(token);
   token = this.parseArgumentsOpt(token);
   this.listener.endSend$1(token);
   return token;
 }
-scanner_Parser.prototype.parseArgumentsOpt = function(token) {
+Parser.prototype.parseArgumentsOpt = function(token) {
   if (!$notnull_bool(this.optional('(', token))) {
     this.listener.handleNoArguments$1(token);
     return token;
   }
   else {
     return this.parseArguments(token);
   }
 }
-scanner_Parser.prototype.parseArguments = function(token) {
+Parser.prototype.parseArguments = function(token) {
   var begin = token;
   this.listener.beginArguments$1(begin);
   $assert('(' === token.get$stringValue(), "'(' === token.stringValue", "parser.dart", 726, 12);
   var argumentCount = 0;
   if ($notnull_bool(this.optional(')', token.next))) {
     this.listener.endArguments$3(argumentCount, begin, token.next);
     return token.next.next;
   }
   do {
     token = this.parseExpression(this.next(token));
     ++argumentCount;
   }
   while ($notnull_bool(this.optional(',', token)))
   this.listener.endArguments$3(argumentCount, begin, token);
   return this.expect(')', token);
 }
-scanner_Parser.prototype.parseVariablesDeclaration = function(token) {
+Parser.prototype.parseVariablesDeclaration = function(token) {
   var count = 1;
   this.listener.beginVariablesDeclaration$1(token);
   token = this.parseFinalVarOrType(token);
   token = this.parseOptionallyInitializedIdentifier(token);
   while ($notnull_bool(this.optional(',', token))) {
     token = this.parseOptionallyInitializedIdentifier(this.next(token));
     ++count;
   }
   this.listener.endVariablesDeclaration$2(count, token);
   return this.expectSemicolon(token);
 }
-scanner_Parser.prototype.parseOptionallyInitializedIdentifier = function(token) {
+Parser.prototype.parseOptionallyInitializedIdentifier = function(token) {
   this.listener.beginInitializedIdentifier$1(token);
   token = this.parseIdentifier(token);
   if ($notnull_bool(this.optional('=', token))) {
     var assignment = token;
     this.listener.beginInitializer$1(token);
     token = this.parseExpression(this.next(token));
     this.listener.endInitializer$1(assignment);
   }
   this.listener.endInitializedIdentifier$0();
   return token;
 }
-scanner_Parser.prototype.parseFinalVarOrType = function(token) {
+Parser.prototype.parseFinalVarOrType = function(token) {
   var value = token.get$stringValue();
   switch (true) {
     case 'final' === value:
 
       this.listener.handleFinalKeyword$1(token);
       return this.next(token);
 
     default:
 
       return this.parseType(token);
 
   }
 }
-scanner_Parser.prototype.parseIfStatement = function(token) {
+Parser.prototype.parseIfStatement = function(token) {
   var ifToken = token;
   this.listener.beginIfStatement$1(ifToken);
   token = this.expect('if', token);
   this.expect('(', token);
   token = this.parseArguments(token);
   token = this.parseStatement(token);
   var elseToken = null;
   if ($notnull_bool(this.optional('else', token))) {
     elseToken = token;
     token = this.parseStatement(token.next);
   }
   this.listener.endIfStatement$2(ifToken, elseToken);
   return token;
 }
-scanner_Parser.prototype.parseForStatement = function(token) {
+Parser.prototype.parseForStatement = function(token) {
   var forToken = token;
   this.listener.beginForStatement$1(forToken);
   token = this.expect('for', token);
   token = this.expect('(', token);
   token = this.parseVariablesDeclaration(token);
   token = this.parseExpressionStatement(token);
   token = this.parseExpression(token);
   token = this.expect(')', token);
   token = this.parseStatement(token);
   this.listener.endForStatement$2(forToken, token);
   return token;
 }
-scanner_Parser.prototype.parseBlock = function(token) {
+Parser.prototype.parseBlock = function(token) {
   var begin = token;
   this.listener.beginBlock$1(begin);
   var statementCount = 0;
   token = this.expect('{', token);
   while (!$notnull_bool(this.optional('}', token))) {
     token = this.parseStatement(token);
     ++statementCount;
   }
   this.listener.endBlock$3(statementCount, begin, token);
   return this.expect('}', token);
 }
-scanner_Parser.prototype.parseThrowStatement = function(token) {
+Parser.prototype.parseThrowStatement = function(token) {
   var throwToken = token;
   this.listener.beginThrowStatement$1(throwToken);
   token = this.expect('throw', token);
   if ($notnull_bool(this.optional(';', token))) {
     this.listener.endRethrowStatement$2(throwToken, token);
     return token.next;
   }
   else {
     token = this.parseExpression(token);
     this.listener.endThrowStatement$2(throwToken, token);
     return this.expectSemicolon(token);
   }
 }
-scanner_Parser.prototype.parseFunction$1 = function($0) {
-  return this.parseFunction(($0 && $0.is$scanner_Token()));
+Parser.prototype.parseFunction$1 = function($0) {
+  return this.parseFunction(($0 && $0.is$Token()));
 };
 // ********** Code for ParserTask **************
 function ParserTask(compiler) {
   // Initializers done
   CompilerTask.call(this, compiler);
 }
 $inherits(ParserTask, CompilerTask);
 ParserTask.prototype.get$name = function() {
   return 'Parser';
 }
 ParserTask.prototype.parse = function(element) {
   var $this = this; // closure support
   var $0;
   return (($0 = this.measure((function () {
     return element.parseNode($this.compiler, $this.compiler);
   })
-  )) && $0.is$tree_Node());
+  )) && $0.is$Node());
 }
 // ********** Code for Listener **************
 function Listener() {
   // Initializers done
 }
 Listener.prototype.beginArguments = function(token) {
 
 }
 Listener.prototype.endArguments = function(count, beginToken, endToken) {
 
@@ skipping 199 matching lines @@
 Listener.prototype.expectedType = function(token) {
   $throw(new ParserError(("Expected a type, but got '" + token + "' @ ") + ("" + token.charOffset + "")));
 }
 Listener.prototype.expectedBlock = function(token) {
   $throw(new ParserError(("Expected a block, but got '" + token + "' @ ") + ("" + token.charOffset + "")));
 }
 Listener.prototype.unexpected = function(token) {
   $throw(new ParserError(("Unexpected token '" + token + "' @ " + token.charOffset + "")));
 }
 Listener.prototype.beginArguments$1 = function($0) {
-  return this.beginArguments(($0 && $0.is$scanner_Token()));
+  return this.beginArguments(($0 && $0.is$Token()));
 };
 Listener.prototype.beginBlock$1 = function($0) {
-  return this.beginBlock(($0 && $0.is$scanner_Token()));
+  return this.beginBlock(($0 && $0.is$Token()));
 };
 Listener.prototype.beginClass$1 = function($0) {
-  return this.beginClass(($0 && $0.is$scanner_Token()));
+  return this.beginClass(($0 && $0.is$Token()));
 };
 Listener.prototype.beginExpressionStatement$1 = function($0) {
-  return this.beginExpressionStatement(($0 && $0.is$scanner_Token()));
+  return this.beginExpressionStatement(($0 && $0.is$Token()));
 };
 Listener.prototype.beginForStatement$1 = function($0) {
-  return this.beginForStatement(($0 && $0.is$scanner_Token()));
+  return this.beginForStatement(($0 && $0.is$Token()));
 };
 Listener.prototype.beginFormalParameter$1 = function($0) {
-  return this.beginFormalParameter(($0 && $0.is$scanner_Token()));
+  return this.beginFormalParameter(($0 && $0.is$Token()));
 };
 Listener.prototype.beginFormalParameters$1 = function($0) {
-  return this.beginFormalParameters(($0 && $0.is$scanner_Token()));
+  return this.beginFormalParameters(($0 && $0.is$Token()));
 };
 Listener.prototype.beginFunction$1 = function($0) {
-  return this.beginFunction(($0 && $0.is$scanner_Token()));
+  return this.beginFunction(($0 && $0.is$Token()));
 };
 Listener.prototype.beginFunctionBody$1 = function($0) {
-  return this.beginFunctionBody(($0 && $0.is$scanner_Token()));
+  return this.beginFunctionBody(($0 && $0.is$Token()));
 };
 Listener.prototype.beginFunctionName$1 = function($0) {
-  return this.beginFunctionName(($0 && $0.is$scanner_Token()));
+  return this.beginFunctionName(($0 && $0.is$Token()));
 };
 Listener.prototype.beginFunctionTypeAlias$1 = function($0) {
-  return this.beginFunctionTypeAlias(($0 && $0.is$scanner_Token()));
+  return this.beginFunctionTypeAlias(($0 && $0.is$Token()));
 };
 Listener.prototype.beginIfStatement$1 = function($0) {
-  return this.beginIfStatement(($0 && $0.is$scanner_Token()));
+  return this.beginIfStatement(($0 && $0.is$Token()));
 };
 Listener.prototype.beginInitializedIdentifier$1 = function($0) {
-  return this.beginInitializedIdentifier(($0 && $0.is$scanner_Token()));
+  return this.beginInitializedIdentifier(($0 && $0.is$Token()));
 };
 Listener.prototype.beginInitializer$1 = function($0) {
-  return this.beginInitializer(($0 && $0.is$scanner_Token()));
+  return this.beginInitializer(($0 && $0.is$Token()));
 };
 Listener.prototype.beginInterface$1 = function($0) {
-  return this.beginInterface(($0 && $0.is$scanner_Token()));
+  return this.beginInterface(($0 && $0.is$Token()));
 };
 Listener.prototype.beginLibraryTag$1 = function($0) {
-  return this.beginLibraryTag(($0 && $0.is$scanner_Token()));
+  return this.beginLibraryTag(($0 && $0.is$Token()));
 };
 Listener.prototype.beginReturnStatement$1 = function($0) {
-  return this.beginReturnStatement(($0 && $0.is$scanner_Token()));
+  return this.beginReturnStatement(($0 && $0.is$Token()));
 };
 Listener.prototype.beginSend$1 = function($0) {
-  return this.beginSend(($0 && $0.is$scanner_Token()));
+  return this.beginSend(($0 && $0.is$Token()));
 };
 Listener.prototype.beginThrowStatement$1 = function($0) {
-  return this.beginThrowStatement(($0 && $0.is$scanner_Token()));
+  return this.beginThrowStatement(($0 && $0.is$Token()));
 };
 Listener.prototype.beginTopLevelMember$1 = function($0) {
-  return this.beginTopLevelMember(($0 && $0.is$scanner_Token()));
+  return this.beginTopLevelMember(($0 && $0.is$Token()));
 };
 Listener.prototype.beginTypeArguments$1 = function($0) {
-  return this.beginTypeArguments(($0 && $0.is$scanner_Token()));
+  return this.beginTypeArguments(($0 && $0.is$Token()));
 };
 Listener.prototype.beginTypeVariable$1 = function($0) {
-  return this.beginTypeVariable(($0 && $0.is$scanner_Token()));
+  return this.beginTypeVariable(($0 && $0.is$Token()));
 };
 Listener.prototype.beginTypeVariables$1 = function($0) {
-  return this.beginTypeVariables(($0 && $0.is$scanner_Token()));
+  return this.beginTypeVariables(($0 && $0.is$Token()));
 };
 Listener.prototype.beginVariablesDeclaration$1 = function($0) {
-  return this.beginVariablesDeclaration(($0 && $0.is$scanner_Token()));
+  return this.beginVariablesDeclaration(($0 && $0.is$Token()));
 };
 Listener.prototype.endArguments$3 = function($0, $1, $2) {
-  return this.endArguments($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endArguments($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 Listener.prototype.endBlock$3 = function($0, $1, $2) {
-  return this.endBlock($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endBlock($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 Listener.prototype.endClass$5 = function($0, $1, $2, $3, $4) {
-  return this.endClass($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()), ($3 && $3.is$scanner_Token()), ($4 && $4.is$scanner_Token()));
+  return this.endClass($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()), ($3 && $3.is$Token()), ($4 && $4.is$Token()));
 };
 Listener.prototype.endExpressionStatement$1 = function($0) {
-  return this.endExpressionStatement(($0 && $0.is$scanner_Token()));
+  return this.endExpressionStatement(($0 && $0.is$Token()));
 };
 Listener.prototype.endForStatement$2 = function($0, $1) {
-  return this.endForStatement(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endForStatement(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 Listener.prototype.endFormalParameter$1 = function($0) {
-  return this.endFormalParameter(($0 && $0.is$scanner_Token()));
+  return this.endFormalParameter(($0 && $0.is$Token()));
 };
 Listener.prototype.endFormalParameters$3 = function($0, $1, $2) {
-  return this.endFormalParameters($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endFormalParameters($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 Listener.prototype.endFunctionBody$3 = function($0, $1, $2) {
-  return this.endFunctionBody($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endFunctionBody($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 Listener.prototype.endFunctionName$1 = function($0) {
-  return this.endFunctionName(($0 && $0.is$scanner_Token()));
+  return this.endFunctionName(($0 && $0.is$Token()));
 };
 Listener.prototype.endFunctionTypeAlias$1 = function($0) {
-  return this.endFunctionTypeAlias(($0 && $0.is$scanner_Token()));
+  return this.endFunctionTypeAlias(($0 && $0.is$Token()));
 };
 Listener.prototype.endIfStatement$2 = function($0, $1) {
-  return this.endIfStatement(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endIfStatement(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 Listener.prototype.endInitializedIdentifier$0 = function() {
   return this.endInitializedIdentifier();
 };
 Listener.prototype.endInitializer$1 = function($0) {
-  return this.endInitializer(($0 && $0.is$scanner_Token()));
+  return this.endInitializer(($0 && $0.is$Token()));
 };
 Listener.prototype.endInterface$1 = function($0) {
-  return this.endInterface(($0 && $0.is$scanner_Token()));
+  return this.endInterface(($0 && $0.is$Token()));
 };
 Listener.prototype.endRethrowStatement$2 = function($0, $1) {
-  return this.endRethrowStatement(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endRethrowStatement(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 Listener.prototype.endReturnStatement$3 = function($0, $1, $2) {
-  return this.endReturnStatement($assert_bool($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endReturnStatement($assert_bool($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 Listener.prototype.endSend$1 = function($0) {
-  return this.endSend(($0 && $0.is$scanner_Token()));
+  return this.endSend(($0 && $0.is$Token()));
 };
 Listener.prototype.endThrowStatement$2 = function($0, $1) {
-  return this.endThrowStatement(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endThrowStatement(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 Listener.prototype.endTopLevelField$2 = function($0, $1) {
-  return this.endTopLevelField(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endTopLevelField(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 Listener.prototype.endTopLevelMethod$2 = function($0, $1) {
-  return this.endTopLevelMethod(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endTopLevelMethod(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 Listener.prototype.endType$3 = function($0, $1, $2) {
-  return this.endType($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endType($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 Listener.prototype.endTypeArguments$3 = function($0, $1, $2) {
-  return this.endTypeArguments($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endTypeArguments($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 Listener.prototype.endTypeVariable$1 = function($0) {
-  return this.endTypeVariable(($0 && $0.is$scanner_Token()));
+  return this.endTypeVariable(($0 && $0.is$Token()));
 };
 Listener.prototype.endTypeVariables$3 = function($0, $1, $2) {
-  return this.endTypeVariables($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endTypeVariables($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 Listener.prototype.endVariablesDeclaration$2 = function($0, $1) {
-  return this.endVariablesDeclaration($assert_num($0), ($1 && $1.is$scanner_Token()));
+  return this.endVariablesDeclaration($assert_num($0), ($1 && $1.is$Token()));
 };
 Listener.prototype.expected$2 = function($0, $1) {
-  return this.expected($assert_String($0), ($1 && $1.is$scanner_Token()));
+  return this.expected($assert_String($0), ($1 && $1.is$Token()));
 };
 Listener.prototype.expectedBlock$1 = function($0) {
-  return this.expectedBlock(($0 && $0.is$scanner_Token()));
+  return this.expectedBlock(($0 && $0.is$Token()));
 };
 Listener.prototype.expectedIdentifier$1 = function($0) {
-  return this.expectedIdentifier(($0 && $0.is$scanner_Token()));
+  return this.expectedIdentifier(($0 && $0.is$Token()));
 };
 Listener.prototype.expectedType$1 = function($0) {
-  return this.expectedType(($0 && $0.is$scanner_Token()));
+  return this.expectedType(($0 && $0.is$Token()));
 };
 Listener.prototype.handleAssignmentExpression$1 = function($0) {
-  return this.handleAssignmentExpression(($0 && $0.is$scanner_Token()));
+  return this.handleAssignmentExpression(($0 && $0.is$Token()));
 };
 Listener.prototype.handleBinaryExpression$1 = function($0) {
-  return this.handleBinaryExpression(($0 && $0.is$scanner_Token()));
+  return this.handleBinaryExpression(($0 && $0.is$Token()));
 };
 Listener.prototype.handleConditionalExpression$2 = function($0, $1) {
-  return this.handleConditionalExpression(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.handleConditionalExpression(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 Listener.prototype.handleIdentifier$1 = function($0) {
-  return this.handleIdentifier(($0 && $0.is$scanner_Token()));
+  return this.handleIdentifier(($0 && $0.is$Token()));
 };
 Listener.prototype.handleLiteralBool$1 = function($0) {
-  return this.handleLiteralBool(($0 && $0.is$scanner_Token()));
+  return this.handleLiteralBool(($0 && $0.is$Token()));
 };
 Listener.prototype.handleLiteralDouble$1 = function($0) {
-  return this.handleLiteralDouble(($0 && $0.is$scanner_Token()));
+  return this.handleLiteralDouble(($0 && $0.is$Token()));
 };
 Listener.prototype.handleLiteralInt$1 = function($0) {
-  return this.handleLiteralInt(($0 && $0.is$scanner_Token()));
+  return this.handleLiteralInt(($0 && $0.is$Token()));
 };
 Listener.prototype.handleLiteralString$1 = function($0) {
-  return this.handleLiteralString(($0 && $0.is$scanner_Token()));
+  return this.handleLiteralString(($0 && $0.is$Token()));
 };
 Listener.prototype.handleNoArguments$1 = function($0) {
-  return this.handleNoArguments(($0 && $0.is$scanner_Token()));
+  return this.handleNoArguments(($0 && $0.is$Token()));
 };
 Listener.prototype.handleNoType$1 = function($0) {
-  return this.handleNoType(($0 && $0.is$scanner_Token()));
+  return this.handleNoType(($0 && $0.is$Token()));
 };
 Listener.prototype.handleNoTypeArguments$1 = function($0) {
-  return this.handleNoTypeArguments(($0 && $0.is$scanner_Token()));
+  return this.handleNoTypeArguments(($0 && $0.is$Token()));
 };
 Listener.prototype.handleNoTypeVariables$1 = function($0) {
-  return this.handleNoTypeVariables(($0 && $0.is$scanner_Token()));
+  return this.handleNoTypeVariables(($0 && $0.is$Token()));
 };
 Listener.prototype.handleUnaryPostfixExpression$1 = function($0) {
-  return this.handleUnaryPostfixExpression(($0 && $0.is$scanner_Token()));
+  return this.handleUnaryPostfixExpression(($0 && $0.is$Token()));
 };
 Listener.prototype.handleUnaryPrefixExpression$1 = function($0) {
-  return this.handleUnaryPrefixExpression(($0 && $0.is$scanner_Token()));
+  return this.handleUnaryPrefixExpression(($0 && $0.is$Token()));
 };
 Listener.prototype.handleVarKeyword$1 = function($0) {
-  return this.handleVarKeyword(($0 && $0.is$scanner_Token()));
+  return this.handleVarKeyword(($0 && $0.is$Token()));
 };
 Listener.prototype.handleVoidKeyword$1 = function($0) {
-  return this.handleVoidKeyword(($0 && $0.is$scanner_Token()));
+  return this.handleVoidKeyword(($0 && $0.is$Token()));
 };
 Listener.prototype.unexpected$1 = function($0) {
-  return this.unexpected(($0 && $0.is$scanner_Token()));
+  return this.unexpected(($0 && $0.is$Token()));
 };
 Listener.prototype.unexpectedEof$0 = function() {
   return this.unexpectedEof();
 };
 // ********** Code for ParserError **************
 function ParserError(reason) {
   this.reason = reason;
   // Initializers done
 }
 ParserError.prototype.toString = function() {
@@ skipping 13 matching lines @@
 }
 $inherits(ElementListener, Listener);
 ElementListener.prototype.beginLibraryTag = function(token) {
   this.canceler.cancel("Cannot handle library tags");
 }
 ElementListener.prototype.endClass = function(interfacesCount, beginToken, extendsKeyword, implementsKeyword, endToken) {
   var $0;
   for (; interfacesCount > 0; --interfacesCount) {
     this.popNode();
   }
-  var supertype = (($0 = this.popNode()) && $0.is$tree_Identifier());
-  var name = (($0 = this.popNode()) && $0.is$tree_Identifier());
+  var supertype = (($0 = this.popNode()) && $0.is$Identifier());
+  var name = (($0 = this.popNode()) && $0.is$Identifier());
   this.pushElement(new PartialClassElement(name.get$source(), beginToken, endToken));
 }
 ElementListener.prototype.endInterface = function(token) {
   this.canceler.cancel("Cannot handle interfaces");
 }
 ElementListener.prototype.endFunctionTypeAlias = function(token) {
   this.canceler.cancel("Cannot handle typedefs");
 }
 ElementListener.prototype.endTopLevelMethod = function(beginToken, endToken) {
   var $0;
-  var name = (($0 = this.popNode()) && $0.is$tree_Identifier());
+  var name = (($0 = this.popNode()) && $0.is$Identifier());
   this.pushElement(new PartialFunctionElement(name.get$source(), beginToken, endToken));
 }
 ElementListener.prototype.endTopLevelField = function(beginToken, endToken) {
   this.canceler.cancel("Cannot handle fields");
 }
 ElementListener.prototype.handleIdentifier = function(token) {
-  this.pushNode(new tree_Identifier(token));
+  this.pushNode(new Identifier(token));
 }
 ElementListener.prototype.handleNoType = function(token) {
   this.pushNode(null);
 }
 ElementListener.prototype.endTypeVariable = function(token) {
   var $0;
   var bound = (($0 = this.popNode()) && $0.is$TypeAnnotation());
-  var name = (($0 = this.popNode()) && $0.is$tree_Identifier());
+  var name = (($0 = this.popNode()) && $0.is$Identifier());
 }
 ElementListener.prototype.endTypeArguments = function(count, beginToken, endToken) {
   for (; count > 0; --count) {
     this.popNode();
   }
 }
 ElementListener.prototype.expected = function(string, token) {
   this.canceler.cancel(("Expected '" + string + "', but got '" + token + "' ") + ("@ " + token.charOffset + ""));
 }
 ElementListener.prototype.unexpectedEof = function() {
@@ skipping 16 matching lines @@
   this.topLevelElements = (($0 = this.topLevelElements.prepend(element)) && $0.is$Link$Element());
 }
 ElementListener.prototype.pushNode = function(node) {
   var $0;
   this.nodes = (($0 = this.nodes.prepend(node)) && $0.is$Link$Node());
   this.log(("push " + this.nodes + ""));
 }
 ElementListener.prototype.popNode = function() {
   var $0;
   $assert(!$notnull_bool(this.nodes.isEmpty()), "!nodes.isEmpty()", "listener.dart", 343, 12);
-  var node = (($0 = this.nodes.get$head()) && $0.is$tree_Node());
+  var node = (($0 = this.nodes.get$head()) && $0.is$Node());
   this.nodes = (($0 = this.nodes.get$tail()) && $0.is$Link$Node());
   this.log(("pop " + this.nodes + ""));
   return node;
 }
 ElementListener.prototype.log = function(message) {
 
 }
 ElementListener.prototype.beginLibraryTag$1 = function($0) {
-  return this.beginLibraryTag(($0 && $0.is$scanner_Token()));
+  return this.beginLibraryTag(($0 && $0.is$Token()));
 };
 ElementListener.prototype.endClass$5 = function($0, $1, $2, $3, $4) {
-  return this.endClass($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()), ($3 && $3.is$scanner_Token()), ($4 && $4.is$scanner_Token()));
+  return this.endClass($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()), ($3 && $3.is$Token()), ($4 && $4.is$Token()));
 };
 ElementListener.prototype.endFunctionTypeAlias$1 = function($0) {
-  return this.endFunctionTypeAlias(($0 && $0.is$scanner_Token()));
+  return this.endFunctionTypeAlias(($0 && $0.is$Token()));
 };
 ElementListener.prototype.endInterface$1 = function($0) {
-  return this.endInterface(($0 && $0.is$scanner_Token()));
+  return this.endInterface(($0 && $0.is$Token()));
 };
 ElementListener.prototype.endTopLevelField$2 = function($0, $1) {
-  return this.endTopLevelField(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endTopLevelField(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 ElementListener.prototype.endTopLevelMethod$2 = function($0, $1) {
-  return this.endTopLevelMethod(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endTopLevelMethod(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 ElementListener.prototype.endTypeArguments$3 = function($0, $1, $2) {
-  return this.endTypeArguments($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endTypeArguments($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 ElementListener.prototype.endTypeVariable$1 = function($0) {
-  return this.endTypeVariable(($0 && $0.is$scanner_Token()));
+  return this.endTypeVariable(($0 && $0.is$Token()));
 };
 ElementListener.prototype.expected$2 = function($0, $1) {
-  return this.expected($assert_String($0), ($1 && $1.is$scanner_Token()));
+  return this.expected($assert_String($0), ($1 && $1.is$Token()));
 };
 ElementListener.prototype.expectedBlock$1 = function($0) {
-  return this.expectedBlock(($0 && $0.is$scanner_Token()));
+  return this.expectedBlock(($0 && $0.is$Token()));
 };
 ElementListener.prototype.expectedIdentifier$1 = function($0) {
-  return this.expectedIdentifier(($0 && $0.is$scanner_Token()));
+  return this.expectedIdentifier(($0 && $0.is$Token()));
 };
 ElementListener.prototype.expectedType$1 = function($0) {
-  return this.expectedType(($0 && $0.is$scanner_Token()));
+  return this.expectedType(($0 && $0.is$Token()));
 };
 ElementListener.prototype.handleIdentifier$1 = function($0) {
-  return this.handleIdentifier(($0 && $0.is$scanner_Token()));
+  return this.handleIdentifier(($0 && $0.is$Token()));
 };
 ElementListener.prototype.handleNoType$1 = function($0) {
-  return this.handleNoType(($0 && $0.is$scanner_Token()));
+  return this.handleNoType(($0 && $0.is$Token()));
 };
 ElementListener.prototype.unexpected$1 = function($0) {
-  return this.unexpected(($0 && $0.is$scanner_Token()));
+  return this.unexpected(($0 && $0.is$Token()));
 };
 ElementListener.prototype.unexpectedEof$0 = function() {
   return this.unexpectedEof();
 };
 // ********** Code for NodeListener **************
 function NodeListener(canceler, logger) {
   this.logger = logger;
   // Initializers done
   ElementListener.call(this, canceler);
   this.onError = this.get$handleOnError();
 }
 $inherits(NodeListener, ElementListener);
 NodeListener.prototype.endClass = function(interfacesCount, beginToken, extendsKeyword, implementsKeyword, endToken) {
   var $0;
   var interfaces = this.makeNodeList(interfacesCount, implementsKeyword, null, ",");
   var supertype = (($0 = this.popNode()) && $0.is$TypeAnnotation());
-  var name = (($0 = this.popNode()) && $0.is$tree_Identifier());
+  var name = (($0 = this.popNode()) && $0.is$Identifier());
   this.pushNode(new ClassNode(name, supertype, interfaces, beginToken, extendsKeyword, endToken));
 }
 NodeListener.prototype.endFormalParameter = function(token) {
   var $0;
   var name = new NodeList.singleton$ctor(this.popNode());
   var type = (($0 = this.popNode()) && $0.is$TypeAnnotation());
   this.pushNode(new VariableDefinitions(type, null, name, token));
 }
 NodeListener.prototype.endFormalParameters = function(count, beginToken, endToken) {
   this.pushNode(this.makeNodeList(count, beginToken, endToken, ","));
 }
 NodeListener.prototype.endArguments = function(count, beginToken, endToken) {
   this.pushNode(this.makeNodeList(count, beginToken, endToken, ","));
 }
 NodeListener.prototype.handleNoArguments = function(token) {
   this.pushNode(null);
 }
 NodeListener.prototype.endReturnStatement = function(hasExpression, beginToken, endToken) {
   var $0;
-  var expression = (($0 = $notnull_bool(hasExpression) ? this.popNode() : null) && $0.is$tree_Expression());
+  var expression = (($0 = $notnull_bool(hasExpression) ? this.popNode() : null) && $0.is$Expression());
   this.pushNode(new Return(beginToken, endToken, expression));
 }
 NodeListener.prototype.endExpressionStatement = function(token) {
-  this.pushNode(new tree_ExpressionStatement(this.popNode(), token));
+  this.pushNode(new ExpressionStatement(this.popNode(), token));
 }
 NodeListener.prototype.handleOnError = function(token, error) {
   this.canceler.cancel(("internal error @ " + token.charOffset + ": '" + token.get$value() + "'") + (": " + error + ""));
 }
 NodeListener.prototype.get$handleOnError = function() {
   return NodeListener.prototype.handleOnError.bind(this);
 }
 NodeListener.prototype.handleLiteralInt = function(token) {
   this.pushNode(new LiteralInt(token, to$call$2(this.onError)));
 }
@@ skipping 25 matching lines @@
   var condition = this.popNode();
   this.canceler.cancel('conditional expression not implemented yet');
 }
 NodeListener.prototype.endSend = function(token) {
   var $0;
   var arguments = (($0 = this.popNode()) && $0.is$NodeList());
   var selector = this.popNode();
   this.pushNode(new Send(null, selector, arguments));
 }
 NodeListener.prototype.handleVoidKeyword = function(token) {
-  this.pushNode(new TypeAnnotation(new tree_Identifier(token)));
+  this.pushNode(new TypeAnnotation(new Identifier(token)));
 }
 NodeListener.prototype.endFunctionBody = function(count, beginToken, endToken) {
   var $0;
   var block = new Block(this.makeNodeList(count, beginToken, endToken, null));
   var formals = this.popNode();
   var name = this.popNode();
   var type = (($0 = this.popNode()) && $0.is$TypeAnnotation());
   this.pushNode(new FunctionExpression(name, formals, block, type));
 }
 NodeListener.prototype.handleVarKeyword = function(token) {
-  this.pushNode(new tree_Identifier(token));
+  this.pushNode(new Identifier(token));
 }
 NodeListener.prototype.handleFinalKeyword = function(token) {
-  this.pushNode(new tree_Identifier(token));
+  this.pushNode(new Identifier(token));
 }
 NodeListener.prototype.endVariablesDeclaration = function(count, endToken) {
   var $0;
   var variables = this.makeNodeList(count, null, null, ",");
   var type = (($0 = this.popNode()) && $0.is$TypeAnnotation());
   this.pushNode(new VariableDefinitions(type, null, variables, endToken));
 }
 NodeListener.prototype.endInitializer = function(assignmentOperator) {
   var $0;
-  var initializer = (($0 = this.popNode()) && $0.is$tree_Expression());
+  var initializer = (($0 = this.popNode()) && $0.is$Expression());
   var arguments = new NodeList.singleton$ctor(initializer);
-  var name = (($0 = this.popNode()) && $0.is$tree_Expression());
+  var name = (($0 = this.popNode()) && $0.is$Expression());
   this.pushNode(new SendSet(null, name, assignmentOperator, arguments));
 }
 NodeListener.prototype.endIfStatement = function(ifToken, elseToken) {
   var $0;
-  var elsePart = (($0 = (elseToken == null) ? null : this.popNode()) && $0.is$tree_Statement());
-  var thenPart = (($0 = this.popNode()) && $0.is$tree_Statement());
+  var elsePart = (($0 = (elseToken == null) ? null : this.popNode()) && $0.is$Statement());
+  var thenPart = (($0 = this.popNode()) && $0.is$Statement());
   var condition = (($0 = this.popNode()) && $0.is$NodeList());
   this.pushNode(new If(condition, thenPart, elsePart, ifToken, elseToken));
 }
 NodeListener.prototype.endForStatement = function(beginToken, endToken) {
   var $0;
-  var body = (($0 = this.popNode()) && $0.is$tree_Statement());
-  var update = (($0 = this.popNode()) && $0.is$tree_Expression());
-  var condition = (($0 = this.popNode()) && $0.is$tree_ExpressionStatement());
+  var body = (($0 = this.popNode()) && $0.is$Statement());
+  var update = (($0 = this.popNode()) && $0.is$Expression());
+  var condition = (($0 = this.popNode()) && $0.is$ExpressionStatement());
   var initializer = (($0 = this.popNode()) && $0.is$VariableDefinitions());
   this.pushNode(new For(initializer, condition, update, body, beginToken));
 }
 NodeListener.prototype.endBlock = function(count, beginToken, endToken) {
   this.pushNode(new Block(this.makeNodeList(count, beginToken, endToken, null)));
 }
 NodeListener.prototype.endType = function(count, beginToken, endToken) {
   var $0;
-  var type = new TypeAnnotation((($0 = this.popNode()) && $0.is$tree_Identifier()));
+  var type = new TypeAnnotation((($0 = this.popNode()) && $0.is$Identifier()));
   for (; count > 1; --count) {
     this.popNode();
   }
   this.pushNode(type);
 }
 NodeListener.prototype.endThrowStatement = function(throwToken, endToken) {
   var $0;
-  var expression = (($0 = this.popNode()) && $0.is$tree_Expression());
+  var expression = (($0 = this.popNode()) && $0.is$Expression());
   this.pushNode(new Throw(expression, throwToken, endToken));
 }
 NodeListener.prototype.endRethrowStatement = function(throwToken, endToken) {
   this.pushNode(new Throw(null, throwToken, endToken));
 }
 NodeListener.prototype.handleUnaryPostfixExpression = function(token) {
   this.pushNode(new Send.postfix$ctor(this.popNode(), new Operator(token)));
 }
 NodeListener.prototype.handleUnaryPrefixExpression = function(token) {
   this.pushNode(new Send.prefix$ctor(this.popNode(), new Operator(token)));
 }
 NodeListener.prototype.makeNodeList = function(count, beginToken, endToken, delimiter) {
   var $0;
   var nodes = const$14/*const EmptyLink()*/;
   for (; count > 0; --count) {
     nodes = (($0 = nodes.prepend(this.popNode())) && $0.is$Link$Node());
   }
   var sourceDelimiter = (($0 = (delimiter == null) ? null : new StringWrapper(delimiter)) && $0.is$SourceString());
   return new NodeList(beginToken, nodes, endToken, sourceDelimiter);
 }
 NodeListener.prototype.log = function(message) {
   this.logger.log(message);
 }
 NodeListener.prototype.endArguments$3 = function($0, $1, $2) {
-  return this.endArguments($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endArguments($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 NodeListener.prototype.endBlock$3 = function($0, $1, $2) {
-  return this.endBlock($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endBlock($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 NodeListener.prototype.endClass$5 = function($0, $1, $2, $3, $4) {
-  return this.endClass($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()), ($3 && $3.is$scanner_Token()), ($4 && $4.is$scanner_Token()));
+  return this.endClass($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()), ($3 && $3.is$Token()), ($4 && $4.is$Token()));
 };
 NodeListener.prototype.endExpressionStatement$1 = function($0) {
-  return this.endExpressionStatement(($0 && $0.is$scanner_Token()));
+  return this.endExpressionStatement(($0 && $0.is$Token()));
 };
 NodeListener.prototype.endForStatement$2 = function($0, $1) {
-  return this.endForStatement(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endForStatement(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 NodeListener.prototype.endFormalParameter$1 = function($0) {
-  return this.endFormalParameter(($0 && $0.is$scanner_Token()));
+  return this.endFormalParameter(($0 && $0.is$Token()));
 };
 NodeListener.prototype.endFormalParameters$3 = function($0, $1, $2) {
-  return this.endFormalParameters($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endFormalParameters($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 NodeListener.prototype.endFunctionBody$3 = function($0, $1, $2) {
-  return this.endFunctionBody($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endFunctionBody($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 NodeListener.prototype.endIfStatement$2 = function($0, $1) {
-  return this.endIfStatement(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endIfStatement(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 NodeListener.prototype.endInitializer$1 = function($0) {
-  return this.endInitializer(($0 && $0.is$scanner_Token()));
+  return this.endInitializer(($0 && $0.is$Token()));
 };
 NodeListener.prototype.endRethrowStatement$2 = function($0, $1) {
-  return this.endRethrowStatement(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endRethrowStatement(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 NodeListener.prototype.endReturnStatement$3 = function($0, $1, $2) {
-  return this.endReturnStatement($assert_bool($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endReturnStatement($assert_bool($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 NodeListener.prototype.endSend$1 = function($0) {
-  return this.endSend(($0 && $0.is$scanner_Token()));
+  return this.endSend(($0 && $0.is$Token()));
 };
 NodeListener.prototype.endThrowStatement$2 = function($0, $1) {
-  return this.endThrowStatement(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.endThrowStatement(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 NodeListener.prototype.endType$3 = function($0, $1, $2) {
-  return this.endType($assert_num($0), ($1 && $1.is$scanner_Token()), ($2 && $2.is$scanner_Token()));
+  return this.endType($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
 NodeListener.prototype.endVariablesDeclaration$2 = function($0, $1) {
-  return this.endVariablesDeclaration($assert_num($0), ($1 && $1.is$scanner_Token()));
+  return this.endVariablesDeclaration($assert_num($0), ($1 && $1.is$Token()));
 };
 NodeListener.prototype.handleAssignmentExpression$1 = function($0) {
-  return this.handleAssignmentExpression(($0 && $0.is$scanner_Token()));
+  return this.handleAssignmentExpression(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleBinaryExpression$1 = function($0) {
-  return this.handleBinaryExpression(($0 && $0.is$scanner_Token()));
+  return this.handleBinaryExpression(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleConditionalExpression$2 = function($0, $1) {
-  return this.handleConditionalExpression(($0 && $0.is$scanner_Token()), ($1 && $1.is$scanner_Token()));
+  return this.handleConditionalExpression(($0 && $0.is$Token()), ($1 && $1.is$Token()));
 };
 NodeListener.prototype.handleFinalKeyword$1 = function($0) {
-  return this.handleFinalKeyword(($0 && $0.is$scanner_Token()));
+  return this.handleFinalKeyword(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleLiteralBool$1 = function($0) {
-  return this.handleLiteralBool(($0 && $0.is$scanner_Token()));
+  return this.handleLiteralBool(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleLiteralDouble$1 = function($0) {
-  return this.handleLiteralDouble(($0 && $0.is$scanner_Token()));
+  return this.handleLiteralDouble(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleLiteralInt$1 = function($0) {
-  return this.handleLiteralInt(($0 && $0.is$scanner_Token()));
+  return this.handleLiteralInt(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleLiteralString$1 = function($0) {
-  return this.handleLiteralString(($0 && $0.is$scanner_Token()));
+  return this.handleLiteralString(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleNoArguments$1 = function($0) {
-  return this.handleNoArguments(($0 && $0.is$scanner_Token()));
+  return this.handleNoArguments(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleUnaryPostfixExpression$1 = function($0) {
-  return this.handleUnaryPostfixExpression(($0 && $0.is$scanner_Token()));
+  return this.handleUnaryPostfixExpression(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleUnaryPrefixExpression$1 = function($0) {
-  return this.handleUnaryPrefixExpression(($0 && $0.is$scanner_Token()));
+  return this.handleUnaryPrefixExpression(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleVarKeyword$1 = function($0) {
-  return this.handleVarKeyword(($0 && $0.is$scanner_Token()));
+  return this.handleVarKeyword(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleVoidKeyword$1 = function($0) {
-  return this.handleVoidKeyword(($0 && $0.is$scanner_Token()));
+  return this.handleVoidKeyword(($0 && $0.is$Token()));
 };
 // ********** Code for PartialFunctionElement **************
 function PartialFunctionElement(name, beginToken, endToken) {
   this.beginToken = beginToken;
   this.endToken = endToken;
   // Initializers done
   FunctionElement.call(this, name);
 }
 $inherits(PartialFunctionElement, FunctionElement);
 PartialFunctionElement.prototype.parseNode = function(canceler, logger) {
@@ skipping 78 matching lines @@
 }
 SubstringWrapper.prototype.hashCode$0 = function() {
   return this.hashCode();
 };
 SubstringWrapper.prototype.printOn$1 = function($0) {
   return this.printOn(($0 && $0.is$StringBuffer()));
 };
 SubstringWrapper.prototype.toString$0 = function() {
   return this.toString();
 };
-// ********** Code for scanner_Token **************
-function scanner_Token(kind, charOffset) {
+// ********** Code for Token **************
+function Token(kind, charOffset) {
   this.kind = kind;
   this.charOffset = charOffset;
   // Initializers done
 }
-scanner_Token.prototype.is$scanner_Token = function(){return this;};
-scanner_Token.prototype.get$charOffset = function() { return this.charOffset; };
-scanner_Token.prototype.get$value = function() {
+Token.prototype.is$Token = function(){return this;};
+Token.prototype.get$charOffset = function() { return this.charOffset; };
+Token.prototype.get$value = function() {
   return const$112/*const SourceString('EOF')*/;
 }
-scanner_Token.prototype.get$stringValue = function() {
+Token.prototype.get$stringValue = function() {
   return 'EOF';
 }
-scanner_Token.prototype.toString = function() {
+Token.prototype.toString = function() {
   return Strings.String$fromCharCodes$factory([this.kind]);
 }
-scanner_Token.prototype.next$0 = function() {
+Token.prototype.next$0 = function() {
   return this.next();
 };
-scanner_Token.prototype.toString$0 = function() {
+Token.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for KeywordToken **************
 function KeywordToken(value, charOffset) {
   this.value = value;
   // Initializers done
-  scanner_Token.call(this, 107/*null.KEYWORD_TOKEN*/, charOffset);
+  Token.call(this, 107/*null.KEYWORD_TOKEN*/, charOffset);
 }
-$inherits(KeywordToken, scanner_Token);
+$inherits(KeywordToken, Token);
 KeywordToken.prototype.get$value = function() { return this.value; };
 KeywordToken.prototype.get$stringValue = function() {
   return this.value.syntax;
 }
 KeywordToken.prototype.toString = function() {
   return this.value.syntax;
 }
 KeywordToken.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for StringToken **************
 function StringToken(kind, value, charOffset) {
   // Initializers done
   StringToken.fromSource$ctor.call(this, kind, new StringWrapper(value), charOffset);
 }
 StringToken.fromSource$ctor = function(kind, value, charOffset) {
   this.value = value;
   // Initializers done
-  scanner_Token.call(this, kind, charOffset);
+  Token.call(this, kind, charOffset);
 }
 StringToken.fromSource$ctor.prototype = StringToken.prototype;
-$inherits(StringToken, scanner_Token);
+$inherits(StringToken, Token);
 StringToken.prototype.get$value = function() { return this.value; };
 StringToken.prototype.get$stringValue = function() {
   return this.value.get$stringValue();
 }
 StringToken.prototype.toString = function() {
   return this.value.toString();
 }
 StringToken.prototype.toString$0 = function() {
   return this.toString();
 };
@@ skipping 176 matching lines @@
 }
 LeafKeywordState.prototype.toString = function() {
   return this.keyword.syntax;
 }
 LeafKeywordState.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for top level **************
 function parse(canceler, logger, doParse) {
   var listener = new NodeListener(canceler, logger);
-  doParse(new scanner_Parser(listener));
+  doParse(new Parser(listener));
   var node = listener.popNode();
   logger.log(("parsed: " + node + ""));
   return node;
 }
 //  ********** Library tree **************
-// ********** Code for tree_Node **************
-function tree_Node() {
+// ********** Code for Node **************
+function Node() {
   this._hashCode = (Math.random() * 0xFFFFFFFF).toInt();
   // Initializers done
 }
-tree_Node.prototype.is$tree_Node = function(){return this;};
-tree_Node.prototype.hashCode = function() {
+Node.prototype.is$Node = function(){return this;};
+Node.prototype.hashCode = function() {
   return this._hashCode;
 }
-tree_Node.prototype.toString = function() {
+Node.prototype.toString = function() {
   return this.unparse();
 }
-tree_Node.prototype.getObjectDescription = function() {
+Node.prototype.getObjectDescription = function() {
   return Object.prototype.toString.call(this);
 }
-tree_Node.prototype.unparse = function() {
+Node.prototype.unparse = function() {
   var unparser = new Unparser(false);
   try {
     return unparser.unparse(this);
   } catch (e) {
     e = $toDartException(e);
     return ('<<unparse error: ' + this.getObjectDescription() + ': ' + unparser.sb + '>>');
   }
 }
-tree_Node.prototype.accept$1 = function($0) {
+Node.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
-tree_Node.prototype.getBeginToken$0 = function() {
+Node.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
-tree_Node.prototype.getEndToken$0 = function() {
+Node.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
-tree_Node.prototype.hashCode$0 = function() {
+Node.prototype.hashCode$0 = function() {
   return this.hashCode();
 };
-tree_Node.prototype.toString$0 = function() {
+Node.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for ClassNode **************
 function ClassNode(name, superclass, interfaces, beginToken, extendsKeyword, endToken) {
   this.name = name;
   this.superclass = superclass;
   this.interfaces = interfaces;
   this.beginToken = beginToken;
   this.extendsKeyword = extendsKeyword;
   this.endToken = endToken;
   // Initializers done
-  tree_Node.call(this);
+  Node.call(this);
 }
-$inherits(ClassNode, tree_Node);
+$inherits(ClassNode, Node);
 ClassNode.prototype.is$ClassNode = function(){return this;};
 ClassNode.prototype.get$name = function() { return this.name; };
 ClassNode.prototype.get$interfaces = function() { return this.interfaces; };
 ClassNode.prototype.accept = function(visitor) {
   return visitor.visitClassNode(this);
 }
 ClassNode.prototype.get$isInterface = function() {
   return this.beginToken.get$stringValue() === 'interface';
 }
 ClassNode.prototype.get$isClass = function() {
   return !$notnull_bool(this.get$isInterface());
 }
 ClassNode.prototype.getBeginToken = function() {
   return this.beginToken;
 }
 ClassNode.prototype.getEndToken = function() {
   return this.endToken;
 }
 ClassNode.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 ClassNode.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 ClassNode.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
-// ********** Code for tree_Expression **************
-function tree_Expression() {
+// ********** Code for Expression **************
+function Expression() {
   // Initializers done
-  tree_Node.call(this);
+  Node.call(this);
 }
-$inherits(tree_Expression, tree_Node);
-tree_Expression.prototype.is$tree_Expression = function(){return this;};
-// ********** Code for tree_Statement **************
-function tree_Statement() {
+$inherits(Expression, Node);
+Expression.prototype.is$Expression = function(){return this;};
+// ********** Code for Statement **************
+function Statement() {
   // Initializers done
-  tree_Node.call(this);
+  Node.call(this);
 }
-$inherits(tree_Statement, tree_Node);
-tree_Statement.prototype.is$tree_Statement = function(){return this;};
+$inherits(Statement, Node);
+Statement.prototype.is$Statement = function(){return this;};
 // ********** Code for Send **************
 function Send(receiver, selector, argumentsNode) {
   this.receiver = receiver;
   this.selector = selector;
   this.argumentsNode = argumentsNode;
   // Initializers done
-  tree_Expression.call(this);
+  Expression.call(this);
 }
 Send.postfix$ctor = function(receiver, selector) {
   this.receiver = receiver;
   this.selector = selector;
   this.argumentsNode = const$211/*const Postfix()*/;
   // Initializers done
-  tree_Expression.call(this);
+  Expression.call(this);
 }
 Send.postfix$ctor.prototype = Send.prototype;
 Send.prefix$ctor = function(receiver, selector) {
   this.receiver = receiver;
   this.selector = selector;
   this.argumentsNode = const$210/*const Prefix()*/;
   // Initializers done
-  tree_Expression.call(this);
+  Expression.call(this);
 }
 Send.prefix$ctor.prototype = Send.prototype;
-$inherits(Send, tree_Expression);
+$inherits(Send, Expression);
 Send.prototype.is$Send = function(){return this;};
 Send.prototype.get$arguments = function() {
   return this.argumentsNode.nodes;
 }
 Send.prototype.accept = function(visitor) {
   return visitor.visitSend(this);
 }
 Send.prototype.get$isOperator = function() {
   return (this.selector instanceof Operator);
 }
 Send.prototype.get$isPropertyAccess = function() {
   return this.argumentsNode == null;
 }
 Send.prototype.get$isFunctionObjectInvocation = function() {
   return this.selector == null;
 }
 Send.prototype.get$isPrefix = function() {
   return (this.argumentsNode instanceof Prefix);
 }
 Send.prototype.getBeginToken = function() {
   return firstBeginToken(this.receiver, this.selector);
 }
 Send.prototype.getEndToken = function() {
   var $0;
   var token;
   if (this.argumentsNode != null) token = this.argumentsNode.getEndToken();
   if (token != null) return token;
   if (this.selector != null) {
-    return (($0 = this.selector.getEndToken()) && $0.is$scanner_Token());
+    return (($0 = this.selector.getEndToken()) && $0.is$Token());
   }
-  return (($0 = this.receiver.getBeginToken()) && $0.is$scanner_Token());
+  return (($0 = this.receiver.getBeginToken()) && $0.is$Token());
 }
 Send.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 Send.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 Send.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
@@ skipping 23 matching lines @@
 SendSet.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 // ********** Code for NodeList **************
 function NodeList(beginToken, nodes, endToken, delimiter) {
   this.beginToken = beginToken;
   this.nodes = nodes;
   this.endToken = endToken;
   this.delimiter = delimiter;
   // Initializers done
-  tree_Node.call(this);
+  Node.call(this);
 }
 NodeList.singleton$ctor = function(node) {
   // Initializers done
   NodeList.call(this, null, LinkFactory.Link$factory(node));
 }
 NodeList.singleton$ctor.prototype = NodeList.prototype;
-$inherits(NodeList, tree_Node);
+$inherits(NodeList, Node);
 NodeList.prototype.is$NodeList = function(){return this;};
 NodeList.prototype.accept = function(visitor) {
   return visitor.visitNodeList(this);
 }
 NodeList.prototype.getBeginToken = function() {
   var $0;
   if (this.beginToken != null) return this.beginToken;
   if (this.nodes != null) {
     for (var link = this.nodes;
      !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
       if (link.get$head().getBeginToken$0() != null) {
-        return (($0 = link.get$head().getBeginToken$0()) && $0.is$scanner_Token());
+        return (($0 = link.get$head().getBeginToken$0()) && $0.is$Token());
       }
       if (link.get$head().getEndToken$0() != null) {
-        return (($0 = link.get$head().getEndToken$0()) && $0.is$scanner_Token());
+        return (($0 = link.get$head().getEndToken$0()) && $0.is$Token());
       }
     }
   }
   return this.endToken;
 }
 NodeList.prototype.getEndToken = function() {
   var $0;
   if (this.endToken != null) return this.endToken;
   if (this.nodes != null) {
     var link = this.nodes;
     while (!$notnull_bool(link.get$tail().isEmpty$0())) link = (($0 = link.get$tail()) && $0.is$Link$Node());
-    if (link.get$head().getEndToken$0() != null) return (($0 = link.get$head().getEndToken$0()) && $0.is$scanner_Token());
-    if (link.get$head().getBeginToken$0() != null) return (($0 = link.get$head().getBeginToken$0()) && $0.is$scanner_Token());
+    if (link.get$head().getEndToken$0() != null) return (($0 = link.get$head().getEndToken$0()) && $0.is$Token());
+    if (link.get$head().getBeginToken$0() != null) return (($0 = link.get$head().getBeginToken$0()) && $0.is$Token());
   }
   return this.beginToken;
 }
 NodeList.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 NodeList.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 NodeList.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for Block **************
 function Block(statements) {
   this.statements = statements;
   // Initializers done
-  tree_Statement.call(this);
+  Statement.call(this);
 }
-$inherits(Block, tree_Statement);
+$inherits(Block, Statement);
 Block.prototype.accept = function(visitor) {
   return visitor.visitBlock(this);
 }
 Block.prototype.getBeginToken = function() {
   return this.statements.getBeginToken();
 }
 Block.prototype.getEndToken = function() {
   return this.statements.getEndToken();
 }
 Block.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 Block.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 Block.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for If **************
 function If(condition, thenPart, elsePart, ifToken, elseToken) {
   this.condition = condition;
   this.thenPart = thenPart;
   this.elsePart = elsePart;
   this.ifToken = ifToken;
   this.elseToken = elseToken;
   // Initializers done
-  tree_Statement.call(this);
+  Statement.call(this);
 }
-$inherits(If, tree_Statement);
+$inherits(If, Statement);
 If.prototype.get$hasElsePart = function() {
   return this.elsePart != null;
 }
 If.prototype.accept = function(visitor) {
   return visitor.visitIf(this);
 }
 If.prototype.getBeginToken = function() {
   return this.ifToken;
 }
 If.prototype.getEndToken = function() {
@@ skipping 10 matching lines @@
   return this.getEndToken();
 };
 // ********** Code for For **************
 function For(initializer, condition, update, body, forToken) {
   this.initializer = initializer;
   this.condition = condition;
   this.update = update;
   this.body = body;
   this.forToken = forToken;
   // Initializers done
-  tree_Statement.call(this);
+  Statement.call(this);
 }
-$inherits(For, tree_Statement);
+$inherits(For, Statement);
 For.prototype.accept = function(visitor) {
   return visitor.visitFor(this);
 }
 For.prototype.getBeginToken = function() {
   return this.forToken;
 }
 For.prototype.getEndToken = function() {
   return this.body.getEndToken();
 }
 For.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 For.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 For.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for FunctionExpression **************
 function FunctionExpression(name, parameters, body, returnType) {
   this.name = name;
   this.parameters = parameters;
   this.body = body;
   this.returnType = returnType;
   // Initializers done
-  tree_Expression.call(this);
+  Expression.call(this);
 }
-$inherits(FunctionExpression, tree_Expression);
+$inherits(FunctionExpression, Expression);
 FunctionExpression.prototype.is$FunctionExpression = function(){return this;};
 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.accept = function(visitor) {
   return visitor.visitFunctionExpression(this);
 }
 FunctionExpression.prototype.getBeginToken = function() {
   return firstBeginToken(this.returnType, this.name);
 }
 FunctionExpression.prototype.getEndToken = function() {
   return this.body.getEndToken();
 }
 FunctionExpression.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 FunctionExpression.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 FunctionExpression.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for Literal **************
 function Literal(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
-  tree_Expression.call(this);
+  Expression.call(this);
 }
-$inherits(Literal, tree_Expression);
+$inherits(Literal, Expression);
 Literal.prototype.getBeginToken = function() {
   return this.token;
 }
 Literal.prototype.getEndToken = function() {
   return this.token;
 }
 Literal.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 Literal.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for Literal$SourceString **************
 function Literal$SourceString(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
-  tree_Expression.call(this);
+  Expression.call(this);
 }
 $inherits(Literal$SourceString, Literal);
 // ********** Code for Literal$bool **************
 function Literal$bool(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
-  tree_Expression.call(this);
+  Expression.call(this);
 }
 $inherits(Literal$bool, Literal);
 // ********** Code for Literal$double **************
 function Literal$double(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
-  tree_Expression.call(this);
+  Expression.call(this);
 }
 $inherits(Literal$double, Literal);
 // ********** Code for Literal$int **************
 function Literal$int(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
-  tree_Expression.call(this);
+  Expression.call(this);
 }
 $inherits(Literal$int, Literal);
 // ********** Code for LiteralInt **************
 function LiteralInt(token, handler) {
   // Initializers done
   Literal$int.call(this, token, handler);
 }
 $inherits(LiteralInt, Literal$int);
 LiteralInt.prototype.get$value = function() {
   try {
@@ skipping 69 matching lines @@
 LiteralString.prototype.get$value = function() {
   var $0;
   return (($0 = this.token.get$value()) && $0.is$SourceString());
 }
 LiteralString.prototype.accept = function(visitor) {
   return visitor.visitLiteralString(this);
 }
 LiteralString.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
-// ********** Code for tree_Identifier **************
-function tree_Identifier(token) {
+// ********** Code for Identifier **************
+function Identifier(token) {
   this.token = token;
   // Initializers done
-  tree_Expression.call(this);
+  Expression.call(this);
 }
-$inherits(tree_Identifier, tree_Expression);
-tree_Identifier.prototype.is$tree_Identifier = function(){return this;};
-tree_Identifier.prototype.get$source = function() {
+$inherits(Identifier, Expression);
+Identifier.prototype.is$Identifier = function(){return this;};
+Identifier.prototype.get$source = function() {
   var $0;
   return (($0 = this.token.get$value()) && $0.is$SourceString());
 }
-tree_Identifier.prototype.accept = function(visitor) {
+Identifier.prototype.accept = function(visitor) {
   return visitor.visitIdentifier(this);
 }
-tree_Identifier.prototype.getBeginToken = function() {
+Identifier.prototype.getBeginToken = function() {
   return this.token;
 }
-tree_Identifier.prototype.getEndToken = function() {
+Identifier.prototype.getEndToken = function() {
   return this.token;
 }
-tree_Identifier.prototype.accept$1 = function($0) {
+Identifier.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
-tree_Identifier.prototype.getBeginToken$0 = function() {
+Identifier.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
-tree_Identifier.prototype.getEndToken$0 = function() {
+Identifier.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for Operator **************
 function Operator(token) {
   // Initializers done
-  tree_Identifier.call(this, token);
+  Identifier.call(this, token);
 }
-$inherits(Operator, tree_Identifier);
+$inherits(Operator, Identifier);
 Operator.prototype.is$Operator = function(){return this;};
 Operator.prototype.accept = function(visitor) {
   return visitor.visitOperator(this);
 }
 Operator.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 // ********** Code for Return **************
 function Return(beginToken, endToken, expression) {
   this.beginToken = beginToken;
   this.endToken = endToken;
   this.expression = expression;
   // Initializers done
-  tree_Statement.call(this);
+  Statement.call(this);
 }
-$inherits(Return, tree_Statement);
+$inherits(Return, Statement);
 Return.prototype.get$hasExpression = function() {
   return this.expression != null;
 }
 Return.prototype.accept = function(visitor) {
   return visitor.visitReturn(this);
 }
 Return.prototype.getBeginToken = function() {
   return this.beginToken;
 }
 Return.prototype.getEndToken = function() {
   return this.endToken;
 }
 Return.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 Return.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 Return.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
-// ********** Code for tree_ExpressionStatement **************
-function tree_ExpressionStatement(expression, endToken) {
+// ********** Code for ExpressionStatement **************
+function ExpressionStatement(expression, endToken) {
   this.expression = expression;
   this.endToken = endToken;
   // Initializers done
-  tree_Statement.call(this);
+  Statement.call(this);
 }
-$inherits(tree_ExpressionStatement, tree_Statement);
-tree_ExpressionStatement.prototype.is$tree_ExpressionStatement = function(){return this;};
-tree_ExpressionStatement.prototype.accept = function(visitor) {
+$inherits(ExpressionStatement, Statement);
+ExpressionStatement.prototype.is$ExpressionStatement = function(){return this;};
+ExpressionStatement.prototype.accept = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
-tree_ExpressionStatement.prototype.getBeginToken = function() {
+ExpressionStatement.prototype.getBeginToken = function() {
   var $0;
-  return (($0 = this.expression.getBeginToken()) && $0.is$scanner_Token());
+  return (($0 = this.expression.getBeginToken()) && $0.is$Token());
 }
-tree_ExpressionStatement.prototype.getEndToken = function() {
+ExpressionStatement.prototype.getEndToken = function() {
   return this.endToken;
 }
-tree_ExpressionStatement.prototype.accept$1 = function($0) {
+ExpressionStatement.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
-tree_ExpressionStatement.prototype.getBeginToken$0 = function() {
+ExpressionStatement.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
-tree_ExpressionStatement.prototype.getEndToken$0 = function() {
+ExpressionStatement.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for Throw **************
 function Throw(expression, throwToken, endToken) {
   this.expression = expression;
   this.throwToken = throwToken;
   this.endToken = endToken;
   // Initializers done
-  tree_Statement.call(this);
+  Statement.call(this);
 }
-$inherits(Throw, tree_Statement);
+$inherits(Throw, Statement);
 Throw.prototype.accept = function(visitor) {
   return visitor.visitThrow(this);
 }
 Throw.prototype.getBeginToken = function() {
   return this.throwToken;
 }
 Throw.prototype.getEndToken = function() {
   return this.endToken;
 }
 Throw.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 Throw.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 Throw.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for TypeAnnotation **************
 function TypeAnnotation(typeName) {
   this.typeName = typeName;
   // Initializers done
-  tree_Node.call(this);
+  Node.call(this);
 }
-$inherits(TypeAnnotation, tree_Node);
+$inherits(TypeAnnotation, Node);
 TypeAnnotation.prototype.is$TypeAnnotation = function(){return this;};
 TypeAnnotation.prototype.get$typeName = function() { return this.typeName; };
 TypeAnnotation.prototype.accept = function(visitor) {
   return visitor.visitTypeAnnotation(this);
 }
 TypeAnnotation.prototype.getBeginToken = function() {
   var $0;
-  return (($0 = this.typeName.getBeginToken()) && $0.is$scanner_Token());
+  return (($0 = this.typeName.getBeginToken()) && $0.is$Token());
 }
 TypeAnnotation.prototype.getEndToken = function() {
   var $0;
-  return (($0 = this.typeName.getEndToken()) && $0.is$scanner_Token());
+  return (($0 = this.typeName.getEndToken()) && $0.is$Token());
 }
 TypeAnnotation.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 TypeAnnotation.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 TypeAnnotation.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for VariableDefinitions **************
 function VariableDefinitions(type, modifiers, definitions, endToken) {
   this.type = type;
   this.modifiers = modifiers;
   this.definitions = definitions;
   this.endToken = endToken;
   // Initializers done
-  tree_Statement.call(this);
+  Statement.call(this);
 }
-$inherits(VariableDefinitions, tree_Statement);
+$inherits(VariableDefinitions, Statement);
 VariableDefinitions.prototype.is$VariableDefinitions = function(){return this;};
 VariableDefinitions.prototype.get$type = function() { return this.type; };
 VariableDefinitions.prototype.accept = function(visitor) {
   return visitor.visitVariableDefinitions(this);
 }
 VariableDefinitions.prototype.getBeginToken = function() {
   return firstBeginToken(this.type, this.definitions);
 }
 VariableDefinitions.prototype.getEndToken = function() {
   return this.endToken;
@@ skipping 151 matching lines @@
   this.sb.add(' ');
   this.visit(node.definitions);
   if ($notnull_bool($eq(node.endToken.get$value(), const$208/*const SourceString(';')*/))) {
     this.add((($0 = node.endToken.get$value()) && $0.is$SourceString()));
   }
 }
 Unparser.prototype.add$1 = function($0) {
   return this.add(($0 && $0.is$SourceString()));
 };
 Unparser.prototype.visit$1 = function($0) {
-  return this.visit(($0 && $0.is$tree_Node()));
+  return this.visit(($0 && $0.is$Node()));
 };
 // ********** Code for top level **************
 function firstBeginToken(first, second) {
   var $0;
-  return (($0 = (first != null) ? first.getBeginToken() : second.getBeginToken()) && $0.is$scanner_Token());
+  return (($0 = (first != null) ? first.getBeginToken() : second.getBeginToken()) && $0.is$Token());
 }
 //  ********** Library elements **************
 // ********** Code for ElementKind **************
 function ElementKind(id) {
   this.id = id;
   // Initializers done
 }
 // ********** Code for Element **************
 function Element(name, kind, enclosingElement) {
   this.name = name;
@@ skipping 92 matching lines @@
   this.isResolved = true;
 }
 ClassElement.prototype.computeType$2 = ClassElement.prototype.computeType;
 ClassElement.prototype.resolve$1 = function($0) {
   return this.resolve(($0 && $0.is$Compiler()));
 };
 // ********** Code for top level **************
 function getType(annotation, types) {
   var $0;
   if (annotation == null || annotation.typeName == null) {
-    return (($0 = types.dynamicType) && $0.is$leg_Type());
+    return (($0 = types.dynamicType) && $0.is$Type());
   }
-  return (($0 = types.lookup$1(annotation.typeName.get$source())) && $0.is$leg_Type());
+  return (($0 = types.lookup$1(annotation.typeName.get$source())) && $0.is$Type());
 }
 //  ********** Library ssa **************
 // ********** Code for SsaBuilderTask **************
 function SsaBuilderTask(compiler) {
   // Initializers done
   CompilerTask.call(this, compiler);
 }
 $inherits(SsaBuilderTask, CompilerTask);
 SsaBuilderTask.prototype.get$name = function() {
   return 'SSA builder';
 }
 SsaBuilderTask.prototype.build = function(tree, elements) {
   var $this = this; // closure support
   var $0;
   return (($0 = this.measure((function () {
     var $0;
     var function_ = (tree && tree.is$FunctionExpression());
     var graph = $this.compileMethod(function_.parameters, function_.body, elements);
     $assert(graph.isValid(), "graph.isValid()", "builder.dart", 14, 14);
     if (false/*null.GENERATE_SSA_TRACE*/) {
-      var name = (($0 = function_.name) && $0.is$tree_Identifier());
+      var name = (($0 = function_.name) && $0.is$Identifier());
       HTracer.HTracer$singleton$factory().traceCompilation(name.get$source().toString());
       HTracer.HTracer$singleton$factory().traceGraph('builder', graph);
     }
     return graph;
   })
   )) && $0.is$HGraph());
 }
 SsaBuilderTask.prototype.compileMethod = function(parameters, body, elements) {
   var builder = new SsaBuilder(this.compiler, elements);
   var graph = builder.build(parameters, body);
@@ skipping 52 matching lines @@
   if (node != null) node.accept(this);
 }
 SsaBuilder.prototype.visitParameters = function(parameters) {
   var $0;
   var parameterIndex = 0;
   for (var link = parameters.nodes;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var container = (($0 = link.get$head()) && $0.is$VariableDefinitions());
     var identifierLink = container.definitions.nodes;
     $assert(!$notnull_bool(identifierLink.isEmpty()) && $notnull_bool(identifierLink.get$tail().isEmpty$0()), "!identifierLink.isEmpty() && identifierLink.tail.isEmpty()", "builder.dart", 115, 14);
-    if (!(identifierLink.get$head() instanceof tree_Identifier)) {
+    if (!(identifierLink.get$head() instanceof Identifier)) {
       this.compiler.unimplemented("SsaBuilder.visitParameters non-identifier");
     }
-    var parameterId = (($0 = identifierLink.get$head()) && $0.is$tree_Identifier());
+    var parameterId = (($0 = identifierLink.get$head()) && $0.is$Identifier());
     var element = (($0 = this.elements.$index(parameterId)) && $0.is$Element());
     var parameterInstruction = new HParameter(parameterIndex++);
     this.definitions.$setindex(element, parameterInstruction);
     this.add(parameterInstruction);
   }
 }
 SsaBuilder.prototype.visitBlock = function(node) {
   var $0;
   for (var link = node.statements.nodes;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-    this.visit((($0 = link.get$head()) && $0.is$tree_Node()));
+    this.visit((($0 = link.get$head()) && $0.is$Node()));
     if ($notnull_bool(this.isAborted())) {
       if (!this.stack.isEmpty()) this.compiler.cancel('non-empty instruction stack');
       return;
     }
   }
   $assert(!$notnull_bool(this.current.isClosed()), "!current.isClosed()", "builder.dart", 138, 12);
   if (!this.stack.isEmpty()) this.compiler.cancel('non-empty instruction stack');
 }
 SsaBuilder.prototype.visitClassNode = function(node) {
   this.compiler.unimplemented("SsaBuilder.visitClassNode");
@@ skipping 166 matching lines @@
     }
     this.stack.add(this.definitions.$index(element));
   }
   else {
     var link = node.get$arguments();
     if (element.kind === const$204/*ElementKind.FOREIGN*/) {
       link = (($0 = link.get$tail()) && $0.is$Link$Node());
     }
     var arguments = [];
     for (; !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-      this.visit((($0 = link.get$head()) && $0.is$tree_Node()));
+      this.visit((($0 = link.get$head()) && $0.is$Node()));
       arguments.add$1(this.pop());
     }
     if (element.kind === const$204/*ElementKind.FOREIGN*/) {
       var literal = (($0 = node.get$arguments().get$head()) && $0.is$LiteralString());
       this.compiler.ensure((literal instanceof LiteralString));
       this.push(new HInvokeForeign(element, arguments, this.unquote(literal)));
     }
     else {
-      var selector = (($0 = node.selector) && $0.is$tree_Identifier());
+      var selector = (($0 = node.selector) && $0.is$Identifier());
       this.push(new HInvoke(element, arguments));
     }
   }
 }
 SsaBuilder.prototype.visitSendSet = function(node) {
   this.stack.add(this.updateDefinition(node));
 }
 SsaBuilder.prototype.visitLiteralInt = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitLiteralDouble = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitLiteralBool = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitLiteralString = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-    this.visit((($0 = link.get$head()) && $0.is$tree_Node()));
+    this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 SsaBuilder.prototype.visitOperator = function(node) {
   this.compiler.unimplemented("SsaBuilder.visitOperator");
 }
 SsaBuilder.prototype.visitReturn = function(node) {
   if (node.expression == null) {
     this.compiler.unimplemented("SsaBuilder: return without expression");
   }
   this.visit(node.expression);
@@ skipping 10 matching lines @@
 SsaBuilder.prototype.visitTypeAnnotation = function(node) {
 
 }
 SsaBuilder.prototype.updateDefinition = function(node) {
   var $0;
   if (node.receiver != null) {
     this.compiler.unimplemented("SsaBuilder: property access");
   }
   var link = node.get$arguments();
   $assert(!$notnull_bool(link.isEmpty()) && $notnull_bool(link.get$tail().isEmpty$0()), "!link.isEmpty() && link.tail.isEmpty()", "builder.dart", 438, 12);
-  this.visit((($0 = link.get$head()) && $0.is$tree_Node()));
+  this.visit((($0 = link.get$head()) && $0.is$Node()));
   var value = this.pop();
   this.definitions.$setindex(this.elements.$index(node), value);
   return value;
 }
 SsaBuilder.prototype.visitVariableDefinitions = function(node) {
   var $0;
   for (var link = node.definitions.nodes;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-    var definition = (($0 = link.get$head()) && $0.is$tree_Node());
-    if ((definition instanceof tree_Identifier)) {
+    var definition = (($0 = link.get$head()) && $0.is$Node());
+    if ((definition instanceof Identifier)) {
       this.compiler.unimplemented("SsaBuilder.visitVariableDefinitions without initial value");
     }
     else {
       $assert((definition instanceof SendSet), "definition is SendSet", "builder.dart", 454, 16);
       this.updateDefinition((definition && definition.is$SendSet()));
     }
   }
 }
 SsaBuilder.prototype.add$1 = function($0) {
   return this.add(($0 && $0.is$HInstruction()));
 };
 SsaBuilder.prototype.visit$1 = function($0) {
-  return this.visit(($0 && $0.is$tree_Node()));
+  return this.visit(($0 && $0.is$Node()));
 };
 // ********** Code for SsaCodeGeneratorTask **************
 function SsaCodeGeneratorTask(compiler) {
   // Initializers done
   CompilerTask.call(this, compiler);
 }
 $inherits(SsaCodeGeneratorTask, CompilerTask);
 SsaCodeGeneratorTask.prototype.get$name = function() {
   return 'SSA code generator';
 }
 SsaCodeGeneratorTask.prototype.generate = function(tree, graph) {
   var $this = this; // closure support
   return $assert_String(this.measure((function () {
     var $0;
     var function_ = (tree && tree.is$FunctionExpression());
     var parameters = function_.parameters;
     var parameterNames = [];
     for (var link = parameters.nodes;
      !$notnull_bool(link.isEmpty$0()); link = link.get$tail()) {
       var parameter = (($0 = link.get$head()) && $0.is$VariableDefinitions());
       var name = (($0 = parameter.definitions.nodes.get$head().get$source()) && $0.is$SourceString());
       parameterNames.add(JsNames.getValid(('' + name + '')));
     }
-    var name = (($0 = function_.name) && $0.is$tree_Identifier());
+    var name = (($0 = function_.name) && $0.is$Identifier());
     if (false/*null.GENERATE_SSA_TRACE*/) {
       HTracer.HTracer$singleton$factory().traceGraph("codegen", graph);
     }
     var code = $this.generateMethod(name.get$source(), parameterNames, graph);
     return code;
   })
   ));
 }
 SsaCodeGeneratorTask.prototype.generateMethod = function(methodName, parameterNames, graph) {
   new SsaPhiEliminator().visitGraph(graph);
@@ skipping 745 matching lines @@
 HInstruction.prototype.getFlag = function(position) {
   return (this.flags & (1 << position)) != 0;
 }
 HInstruction.prototype.setFlag = function(position) {
   this.flags |= (1 << position);
 }
 HInstruction.computeDependsOnFlags = function(flags) {
   return flags << 1/*HInstruction.FLAG_CHANGES_COUNT*/;
 }
 HInstruction.prototype.getChangesFlags = function() {
-  return this.flags & (1.0)/*((1 << FLAG_CHANGES_COUNT) - 1)*/;
+  return this.flags & (1)/*((1 << FLAG_CHANGES_COUNT) - 1)*/;
 }
 HInstruction.prototype.hasSideEffects = function() {
   return this.getChangesFlags() != 0;
 }
 HInstruction.prototype.prepareGvn = function() {
   this.setAllSideEffects();
 }
 HInstruction.prototype.setAllSideEffects = function() {
-  this.flags |= (1.0)/*((1 << FLAG_CHANGES_COUNT) - 1)*/;
+  this.flags |= (1)/*((1 << FLAG_CHANGES_COUNT) - 1)*/;
 }
 HInstruction.prototype.clearAllSideEffects = function() {
-  this.flags &= -2.0/*~((1 << FLAG_CHANGES_COUNT) - 1)*/;
+  this.flags &= -2/*~((1 << FLAG_CHANGES_COUNT) - 1)*/;
 }
 HInstruction.prototype.generateAtUseSite = function() {
   return this.getFlag(2/*HInstruction.FLAG_GENERATE_AT_USE_SITE*/);
 }
 HInstruction.prototype.setGenerateAtUseSite = function() {
   this.setFlag(2/*HInstruction.FLAG_GENERATE_AT_USE_SITE*/);
 }
 HInstruction.prototype.useGvn = function() {
   return this.getFlag(3/*HInstruction.FLAG_USE_GVN*/);
 }
@@ skipping 1437 matching lines @@
 }
 ResolverTask.prototype.resolveType = function(tree) {
   var $this = this; // closure support
   this.measure((function () {
     var visitor = new ClassResolverVisitor($this.compiler);
     visitor.visit(tree);
   })
   );
 }
 ResolverTask.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$tree_Node()));
+  return this.resolve(($0 && $0.is$Node()));
 };
 // ********** Code for ErrorMessages **************
 function ErrorMessages() {}
 ErrorMessages.cannotResolve = function(id) {
   return ("cannot resolve " + id + "");
 }
 ErrorMessages.cannotResolveType = function(id) {
   return ("cannot resolve type " + id + "");
 }
 ErrorMessages.duplicateDefinition = function(id) {
@@ skipping 65 matching lines @@
   if ($notnull_bool($eq(name, const$217/*const SourceString('*')*/))) return const$218/*const SourceString('mul')*/;
   if ($notnull_bool($eq(name, const$219/*const SourceString('/')*/))) return const$220/*const SourceString('div')*/;
   if ($notnull_bool($eq(name, const$221/*const SourceString('~/')*/))) return const$222/*const SourceString('tdiv')*/;
   if ($notnull_bool($eq(name, const$223/*const SourceString('==')*/))) return const$224/*const SourceString('eq')*/;
   if ($notnull_bool($eq(name, const$225/*const SourceString('<')*/))) return const$226/*const SourceString('lt')*/;
   return name;
 }
 ResolverVisitor.prototype.visitSend = function(node) {
   var $0;
   this.visit(node.receiver);
-  var identifier = (($0 = node.selector) && $0.is$tree_Identifier());
+  var identifier = (($0 = node.selector) && $0.is$Identifier());
   var name = this.potentiallyMapOperatorToMethodName(identifier.get$source());
   var target = this.context.lookup(name);
   if (target == null) this.fail(node, ErrorMessages.cannotResolve(name));
   this.visit(node.argumentsNode);
   return this.useElement(node, target);
 }
 ResolverVisitor.prototype.visitSendSet = function(node) {
   var $0;
   var receiver = (($0 = this.visit(node.receiver)) && $0.is$Element());
-  var selector = (($0 = node.selector) && $0.is$tree_Identifier());
+  var selector = (($0 = node.selector) && $0.is$Identifier());
   if (receiver != null) {
     this.compiler.unimplemented('Resolver: property access');
   }
   var target = this.context.lookup(selector.get$source());
   if (target == null) this.fail(node, ErrorMessages.cannotResolve(node));
   this.visit(node.argumentsNode);
   return this.useElement(node, target);
 }
 ResolverVisitor.prototype.visitLiteralInt = function(node) {
 
 }
 ResolverVisitor.prototype.visitLiteralDouble = function(node) {
 
 }
 ResolverVisitor.prototype.visitLiteralBool = function(node) {
 
 }
 ResolverVisitor.prototype.visitLiteralString = function(node) {
 
 }
 ResolverVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-    this.visit((($0 = link.get$head()) && $0.is$tree_Node()));
+    this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 ResolverVisitor.prototype.visitOperator = function(node) {
   this.fail(node, "Unimplemented in the resolver");
 }
 ResolverVisitor.prototype.visitReturn = function(node) {
   this.visit(node.expression);
 }
 ResolverVisitor.prototype.visitThrow = function(node) {
   this.visit(node.expression);
@@ skipping 25 matching lines @@
   this.compiler.ensure(element != null);
   this.mapping.$setindex(node, element);
   return (($0 = this.context.add(element)) && $0.is$Element());
 }
 ResolverVisitor.prototype.useElement = function(node, element) {
   if (element == null) return null;
   this.mapping.$setindex(node, element);
   return element;
 }
 ResolverVisitor.prototype.visit$1 = function($0) {
-  return this.visit(($0 && $0.is$tree_Node()));
+  return this.visit(($0 && $0.is$Node()));
 };
 // ********** Code for ClassResolverVisitor **************
 function ClassResolverVisitor(compiler) {
   this.compiler = compiler;
   this.context = new TopScope(compiler.universe);
   // Initializers done
 }
 ClassResolverVisitor.prototype.is$Visitor = function(){return this;};
 ClassResolverVisitor.prototype.visitClassNode = function(node) {
   var $0;
   var element = (($0 = this.context.lookup(node.name.get$source())) && $0.is$ClassElement());
   this.compiler.ensure(element != null);
   this.compiler.ensure(!$notnull_bool(element.isResolved));
   element.supertype = this.visit(node.superclass);
   for (var link = node.interfaces.nodes;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-    element.interfaces = (($0 = element.interfaces.prepend(this.visit((($0 = link.get$head()) && $0.is$tree_Node())))) && $0.is$Link$Type());
+    element.interfaces = (($0 = element.interfaces.prepend(this.visit((($0 = link.get$head()) && $0.is$Node())))) && $0.is$Link$Type());
   }
   return element.computeType(this.compiler, null);
 }
 ClassResolverVisitor.prototype.visitTypeAnnotation = function(node) {
   var $0;
   var name = node.typeName;
   var element = this.context.lookup(name.get$source());
   if (element == null) {
     this.compiler.cancel(ErrorMessages.cannotResolveType(name));
   }
   else if (element.kind !== const$199/*ElementKind.CLASS*/) {
     this.compiler.cancel(ErrorMessages.notAType(name));
   }
   else {
     this.compiler.resolver.toResolve.add(element);
-    return (($0 = element.computeType(this.compiler, null)) && $0.is$leg_Type());
+    return (($0 = element.computeType(this.compiler, null)) && $0.is$Type());
   }
   return null;
 }
 ClassResolverVisitor.prototype.visit = function(node) {
   var $0;
   if (node == null) return null;
-  return (($0 = node.accept(this)) && $0.is$leg_Type());
+  return (($0 = node.accept(this)) && $0.is$Type());
 }
 ClassResolverVisitor.prototype.visit$1 = function($0) {
-  return this.visit(($0 && $0.is$tree_Node()));
+  return this.visit(($0 && $0.is$Node()));
 };
 // ********** Code for VariableDefinitionsVisitor **************
 function VariableDefinitionsVisitor(definitions, resolver) {
   this.definitions = definitions;
   this.resolver = resolver;
   // Initializers done
 }
 VariableDefinitionsVisitor.prototype.is$Visitor = function(){return this;};
 VariableDefinitionsVisitor.prototype.visitSendSet = function(node) {
   var $0;
   $assert(node.get$arguments().get$tail().isEmpty$0(), "node.arguments.tail.isEmpty()", "resolver.dart", 269, 12);
   if (node.receiver != null) {
     this.resolver.compiler.unimplemented("receiver on a variable definition");
   }
-  var selector = (($0 = node.selector) && $0.is$tree_Identifier());
-  this.resolver.visit((($0 = node.get$arguments().get$head()) && $0.is$tree_Node()));
+  var selector = (($0 = node.selector) && $0.is$Identifier());
+  this.resolver.visit((($0 = node.get$arguments().get$head()) && $0.is$Node()));
   return (($0 = this.visit(node.selector)) && $0.is$SourceString());
 }
 VariableDefinitionsVisitor.prototype.visitIdentifier = function(node) {
   return node.get$source();
 }
 VariableDefinitionsVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-    var name = (($0 = this.visit((($0 = link.get$head()) && $0.is$tree_Node()))) && $0.is$SourceString());
-    var element = new VariableElement((($0 = link.get$head()) && $0.is$tree_Node()), this.definitions.type, name, this.resolver.context.enclosingElement);
-    var existing = this.resolver.defineElement((($0 = link.get$head()) && $0.is$tree_Node()), element);
+    var name = (($0 = this.visit((($0 = link.get$head()) && $0.is$Node()))) && $0.is$SourceString());
+    var element = new VariableElement((($0 = link.get$head()) && $0.is$Node()), this.definitions.type, name, this.resolver.context.enclosingElement);
+    var existing = this.resolver.defineElement((($0 = link.get$head()) && $0.is$Node()), element);
     if ($ne(existing, element)) {
       this.resolver.fail(node, ErrorMessages.duplicateDefinition(link.get$head()));
     }
   }
 }
 VariableDefinitionsVisitor.prototype.visit = function(node) {
   return node.accept(this);
 }
 VariableDefinitionsVisitor.prototype.visit$1 = function($0) {
-  return this.visit(($0 && $0.is$tree_Node()));
+  return this.visit(($0 && $0.is$Node()));
 };
 // ********** Code for Scope **************
 function Scope(parent) {
   // Initializers done
   Scope.enclosing$ctor.call(this, parent, parent.enclosingElement);
 }
-Scope.enclosing$ctor = function(parent, enclosingElement) {
-  this.parent = parent;
-  this.enclosingElement = enclosingElement;
-  this.elements = $map([]);
-  // Initializers done
-}
-Scope.enclosing$ctor.prototype = Scope.prototype;
 Scope.top$ctor = function() {
   this.parent = null;
   this.elements = const$212/*const {}*/;
   this.enclosingElement = null;
   // Initializers done
 }
 Scope.top$ctor.prototype = Scope.prototype;
+Scope.enclosing$ctor = function(parent, enclosingElement) {
+  this.parent = parent;
+  this.enclosingElement = enclosingElement;
+  this.elements = $map([]);
+  // Initializers done
+}
+Scope.enclosing$ctor.prototype = Scope.prototype;
 Scope.prototype.get$parent = function() { return this.parent; };
 Scope.prototype.lookup = function(name) {
   var $0;
   var element = (($0 = this.elements.$index(name)) && $0.is$Element());
   if (element != null) return element;
   return this.parent.lookup(name);
 }
 Scope.prototype.add = function(element) {
   var $0;
   if (this.elements.containsKey(element.name)) return (($0 = this.elements.$index(element.name)) && $0.is$Element());
@@ skipping 86 matching lines @@
   this.name = name;
   this.element = element;
   // Initializers done
 }
 SimpleType.named$ctor = function(name) {
   this.name = name;
   this.element = new Element(name, null, null);
   // Initializers done
 }
 SimpleType.named$ctor.prototype = SimpleType.prototype;
-SimpleType.prototype.is$leg_Type = function(){return this;};
+SimpleType.prototype.is$Type = function(){return this;};
 SimpleType.prototype.get$name = function() { return this.name; };
 SimpleType.prototype.get$element = function() { return this.element; };
 SimpleType.prototype.toString = function() {
   return this.name.toString();
 }
 SimpleType.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for FunctionType **************
 function FunctionType(returnType, parameterTypes) {
   this.returnType = returnType;
   this.parameterTypes = parameterTypes;
   // Initializers done
 }
 FunctionType.prototype.is$FunctionType = function(){return this;};
-FunctionType.prototype.is$leg_Type = function(){return this;};
+FunctionType.prototype.is$Type = function(){return this;};
 FunctionType.prototype.get$returnType = function() { return this.returnType; };
 FunctionType.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   var first = true;
   sb.add('(');
   this.parameterTypes.printOn(sb, ', ');
   sb.add((') -> ' + this.returnType + ''));
   return sb.toString();
 }
 FunctionType.prototype.toString$0 = function() {
@@ skipping 62 matching lines @@
     this.reportTypeWarning(node, const$243/*WarningKind.VOID_EXPRESSION*/, const$13/*const []*/);
   }
   return type;
 }
 TypeCheckerVisitor.prototype.typeWithDefault = function(node, defaultValue) {
   return node != null ? this.type(node) : defaultValue;
 }
 TypeCheckerVisitor.prototype.type = function(node) {
   var $0;
   if (node == null) this.fail(null, 'unexpected node: null');
-  var result = (($0 = node.accept(this)) && $0.is$leg_Type());
+  var result = (($0 = node.accept(this)) && $0.is$Type());
   return result;
 }
 TypeCheckerVisitor.prototype.get$type = function() {
   return TypeCheckerVisitor.prototype.type.bind(this);
 }
 TypeCheckerVisitor.prototype.checkAssignable = function(node, s, t) {
   if (!$notnull_bool(this.types.isAssignable(s, t))) {
     this.reportTypeWarning(node, const$236/*WarningKind.NOT_ASSIGNABLE*/, [s, t]);
   }
 }
@@ skipping 25 matching lines @@
 }
 TypeCheckerVisitor.prototype.visitIf = function(node) {
   this.type(node.condition);
   this.type(node.thenPart);
   if ($notnull_bool(node.get$hasElsePart())) this.type(node.elsePart);
   return this.types.voidType;
 }
 TypeCheckerVisitor.prototype.visitSend = function(node) {
   var $0;
   var target = this.elements.$index(node);
-  var selector = (($0 = node.selector) && $0.is$tree_Identifier());
+  var selector = (($0 = node.selector) && $0.is$Identifier());
   if (target != null) {
     var name = selector.get$source();
     if ($notnull_bool($eq(name, const$213/*const SourceString('+')*/)) || $notnull_bool($eq(name, const$240/*const SourceString('=')*/)) || $notnull_bool($eq(name, const$215/*const SourceString('-')*/)) || $notnull_bool($eq(name, const$217/*const SourceString('*')*/)) || $notnull_bool($eq(name, const$219/*const SourceString('/')*/)) || $notnull_bool($eq(name, const$225/*const SourceString('<')*/)) || $notnull_bool($eq(name, const$221/*const SourceString('~/')*/))) {
       return this.types.dynamicType;
     }
     var targetType = target.computeType$2(this.compiler, this.types);
     if ($notnull_bool(node.get$isPropertyAccess())) {
-      return (targetType && targetType.is$leg_Type());
+      return (targetType && targetType.is$Type());
     }
     else if ($notnull_bool(node.get$isFunctionObjectInvocation())) {
       this.fail(node);
     }
     else {
       if (!(targetType instanceof FunctionType)) {
         if ((target instanceof ForeignElement)) {
           return this.types.dynamicType;
         }
         this.fail(node, 'can only handle function types');
       }
       var funType = (targetType && targetType.is$FunctionType());
       var formals = funType.parameterTypes;
       var arguments = node.get$arguments();
       while ((!$notnull_bool(formals.isEmpty())) && (!$notnull_bool(arguments.isEmpty()))) {
-        var argument = (($0 = arguments.get$head()) && $0.is$tree_Node());
+        var argument = (($0 = arguments.get$head()) && $0.is$Node());
         var argumentType = this.type(argument);
-        this.checkAssignable(argument, argumentType, (($0 = formals.get$head()) && $0.is$leg_Type()));
+        this.checkAssignable(argument, argumentType, (($0 = formals.get$head()) && $0.is$Type()));
         formals = (($0 = formals.get$tail()) && $0.is$Link$Type());
         arguments = (($0 = arguments.get$tail()) && $0.is$Link$Node());
       }
       if (!$notnull_bool(formals.isEmpty())) {
         this.compiler.reportWarning(node, 'missing argument');
       }
       if (!$notnull_bool(arguments.isEmpty())) {
-        this.compiler.reportWarning((($0 = arguments.get$head()) && $0.is$tree_Node()), 'additional arguments');
+        this.compiler.reportWarning((($0 = arguments.get$head()) && $0.is$Node()), 'additional arguments');
       }
       return funType.returnType;
     }
   }
   else {
     this.fail(node, ('unresolved send ' + selector.get$source() + ''));
   }
 }
 TypeCheckerVisitor.prototype.visitSendSet = function(node) {
   var $0;
   this.compiler.ensure(node.get$arguments() != null && !$notnull_bool(node.get$arguments().isEmpty()));
-  var targetType = (($0 = this.elements.$index(node).computeType$2(this.compiler, this.types)) && $0.is$leg_Type());
-  var value = (($0 = node.get$arguments().get$head()) && $0.is$tree_Node());
+  var targetType = (($0 = this.elements.$index(node).computeType$2(this.compiler, this.types)) && $0.is$Type());
+  var value = (($0 = node.get$arguments().get$head()) && $0.is$Node());
   this.checkAssignable(value, this.type(value), targetType);
   return targetType;
 }
 TypeCheckerVisitor.prototype.visitLiteralInt = function(node) {
   return this.types.intType;
 }
 TypeCheckerVisitor.prototype.visitLiteralDouble = function(node) {
   return this.types.dynamicType;
 }
 TypeCheckerVisitor.prototype.visitLiteralBool = function(node) {
   return this.types.dynamicType;
 }
 TypeCheckerVisitor.prototype.visitLiteralString = function(node) {
   return this.types.stringType;
 }
 TypeCheckerVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-    this.type((($0 = link.get$head()) && $0.is$tree_Node()));
+    this.type((($0 = link.get$head()) && $0.is$Node()));
   }
   return null;
 }
 TypeCheckerVisitor.prototype.visitOperator = function(node) {
   return this.types.dynamicType;
 }
 TypeCheckerVisitor.prototype.visitReturn = function(node) {
   var expression = node.expression;
   var isVoidFunction = (this.expectedReturnType === this.types.voidType);
   if (expression != null) {
@@ skipping 23 matching lines @@
 }
 TypeCheckerVisitor.prototype.visitVariableDefinitions = function(node) {
   var $0;
   var type = this.typeWithDefault(node.type, this.types.dynamicType);
   if ($eq(type, this.types.voidType)) {
     this.reportTypeWarning(node.type, const$241/*WarningKind.VOID_VARIABLE*/, const$13/*const []*/);
     type = this.types.dynamicType;
   }
   for (var link = node.definitions.nodes;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-    var initialization = (($0 = link.get$head()) && $0.is$tree_Node());
-    this.compiler.ensure((initialization instanceof tree_Identifier) || (initialization instanceof Send));
+    var initialization = (($0 = link.get$head()) && $0.is$Node());
+    this.compiler.ensure((initialization instanceof Identifier) || (initialization instanceof Send));
     if ((initialization instanceof Send)) {
-      var initializer = this.nonVoidType((($0 = link.get$head()) && $0.is$tree_Node()));
+      var initializer = this.nonVoidType((($0 = link.get$head()) && $0.is$Node()));
       this.checkAssignable(node, type, initializer);
     }
   }
   return null;
 }
 // ********** Code for Universe **************
 function Universe() {
   this.elements = $map([]);
   this.generatedCode = $map([]);
   this.scope = new Element(const$2, null, null);
   // Initializers done
 }
 Universe.prototype.find = function(name) {
   var $0;
   return (($0 = this.elements.$index(name)) && $0.is$Element());
 }
 Universe.prototype.define = function(element) {
   $assert(this.elements.$index(element.name) == null, "elements[element.name] == null", "universe.dart", 20, 12);
   this.elements.$setindex(element.name, element);
 }
 Universe.prototype.addGeneratedCode = function(element, code) {
   this.generatedCode.$setindex(element, code);
 }
 // ********** Code for top level **************
 function unreachable() {
   $throw(const$267/*const Exception("Internal Error (Leg): UNREACHABLE")*/);
 }
-function leg_compile(world) {
+function compile(world) {
   var file = world.readFile(options.dartScript);
   var script = new leg_Script(file);
   var compiler = new WorldCompiler(world, script);
   return compiler.run();
 }
 //  ********** Library lang **************
 // ********** Code for CodeWriter **************
 function CodeWriter() {
   this._indentation = 0
   this._pendingIndent = false
@@ skipping 255 matching lines @@
     var file = $list.$index($i);
     var filename = basename(file.filename);
     this.writer.comment(('//  ********** Natives ' + filename + ' **************'));
     this.writer.writeln(file.get$text());
   }
   lib.topType.markUsed();
   var $list = this._orderValues(lib.types);
   for (var $i = 0;$i < $list.length; $i++) {
     var type = $list.$index($i);
     if ($notnull_bool(type.get$isUsed()) && $notnull_bool(type.get$isClass())) {
-      this.writeType((type && type.is$Type()));
+      this.writeType((type && type.is$lang_Type()));
       if ($notnull_bool(type.get$isGeneric())) {
         var $list0 = this._orderValues(type._concreteTypes);
         for (var $i0 = 0;$i0 < $list0.length; $i0++) {
           var ct = $list0.$index($i0);
-          this.writeType((ct && ct.is$Type()));
+          this.writeType((ct && ct.is$lang_Type()));
         }
       }
     }
     if ($notnull_bool(type.get$isFunction()) && type.varStubs != null) {
       this.writer.comment(('// ********** Code for ' + type.get$jsname() + ' **************'));
-      this._writeDynamicStubs((type && type.is$Type()));
+      this._writeDynamicStubs((type && type.is$lang_Type()));
     }
     if (type.typeCheckCode != null) {
       this.writer.writeln(type.typeCheckCode);
     }
   }
 }
 WorldGenerator.prototype.genMethod = function(meth, enclosingMethod) {
   if (!$notnull_bool(meth.isGenerated) && !$notnull_bool(meth.get$isAbstract()) && $notnull_bool($ne(meth.get$definition(), null))) {
     new MethodGenerator(meth, enclosingMethod).run();
   }
@@ skipping 60 matching lines @@
       }
     }
   }
   if (!(type instanceof ConcreteType)) {
     this._maybeIsTest(type, type);
   }
   if (type.get$genericType()._concreteTypes != null) {
     var $list = this._orderValues(type.get$genericType()._concreteTypes);
     for (var $i = 0;$i < $list.length; $i++) {
       var ct = $list.$index($i);
-      this._maybeIsTest(type, (ct && ct.is$Type()));
+      this._maybeIsTest(type, (ct && ct.is$lang_Type()));
     }
   }
   if (type.get$interfaces() != null) {
     var seen = new HashSetImplementation();
     var worklist = [];
     worklist.addAll(type.get$interfaces());
     seen.addAll(type.get$interfaces());
     while (!worklist.isEmpty()) {
       var interface_ = worklist.removeLast();
       this._maybeIsTest(type, interface_.get$genericType());
       if (interface_.get$genericType()._concreteTypes != null) {
         var $list = this._orderValues(interface_.get$genericType()._concreteTypes);
         for (var $i = 0;$i < $list.length; $i++) {
           var ct = $list.$index($i);
-          this._maybeIsTest(type, (ct && ct.is$Type()));
+          this._maybeIsTest(type, (ct && ct.is$lang_Type()));
         }
       }
       var $list = interface_.get$interfaces();
       for (var $i = interface_.get$interfaces().iterator$0(); $i.hasNext$0(); ) {
         var other = $i.next$0();
         if (!seen.contains(other)) {
           worklist.addLast(other);
           seen.add(other);
         }
       }
@@ skipping 114 matching lines @@
   return WorldGenerator.prototype._compareMembers.bind(this);
 }
 WorldGenerator.prototype.useMapFactory = function() {
   var $0;
   this.corejs.useMap = true;
   var factType = world.get$coreimpl().types.$index('HashMapImplementation');
   var m = factType.resolveMember$1('\$setindex');
   this.genMethod((($0 = m.get$members().$index(0)) && $0.is$Member()));
   var c = factType.getConstructor$1('');
   this.genMethod((c && c.is$Member()));
-  return (factType && factType.is$Type());
+  return (factType && factType.is$lang_Type());
 }
 // ********** Code for BlockScope **************
 function BlockScope(enclosingMethod, parent, reentrant) {
   this.enclosingMethod = enclosingMethod;
   this.parent = parent;
   this.reentrant = reentrant;
   this._vars = $map([]);
   // Initializers done
   if ($notnull_bool(this.get$isMethodScope())) {
     this._closedOver = new HashSetImplementation();
@@ skipping 55 matching lines @@
   var ret = new Value(type, jsName, span, false);
   ret.isFinal = isFinal;
   this._vars.$setindex(name, ret);
   return (ret && ret.is$Value());
 }
 BlockScope.prototype.declareParameter = function(p) {
   return this.create(p.name, p.type, p.definition.span, false, true);
 }
 BlockScope.prototype.declare = function(id) {
   var type = this.enclosingMethod.method.resolveType(id.type, false);
-  return this.create(id.name.name, (type && type.is$Type()), id.span, false, false);
+  return this.create(id.name.name, (type && type.is$lang_Type()), id.span, false, false);
 }
 BlockScope.prototype.getRethrow = function() {
   var scope = this;
   while (scope.rethrow == null && $notnull_bool($ne(scope.get$parent(), null))) {
     scope = scope.get$parent();
   }
   return scope.rethrow;
 }
 BlockScope.prototype.lookup$1 = function($0) {
   return this.lookup($assert_String($0));
@@ skipping 320 matching lines @@
   if ($notnull_bool($ne(initializedFields, null))) {
     var $list = this.method.declaringType.get$members().getKeys();
     for (var $i = this.method.declaringType.get$members().getKeys().iterator$0(); $i.hasNext$0(); ) {
       var name = $i.next$0();
       var member = this.method.declaringType.get$members().$index(name);
       if ((member instanceof FieldMember) && $notnull_bool(member.get$isFinal()) && !$notnull_bool(member.get$isStatic()) && !$notnull_bool(initializedFields.contains$1(name))) {
         world.error(('Field "' + name + '" is final and was not initialized'), this.method.get$definition().get$span());
       }
     }
   }
-  this.visitStatementsInBlock((body && body.is$Statement()));
+  this.visitStatementsInBlock((body && body.is$lang_Statement()));
 }
 MethodGenerator.prototype._writeInitializerCall = function(node) {
   var contructorName = '';
   var targetExp = node.target;
   if ((targetExp instanceof DotExpression)) {
     var dot = (targetExp && targetExp.is$DotExpression());
     targetExp = dot.self;
     contructorName = dot.name.name;
   }
   var target = null;
   if ((targetExp instanceof SuperExpression)) {
-    target = this._makeSuperValue((targetExp && targetExp.is$Node()));
+    target = this._makeSuperValue((targetExp && targetExp.is$lang_Node()));
   }
   else if ((targetExp instanceof ThisExpression)) {
-    target = this._makeThisValue((targetExp && targetExp.is$Node()));
+    target = this._makeThisValue((targetExp && targetExp.is$lang_Node()));
   }
   else {
     world.error('bad call in initializers', node.span);
   }
   var m = target.type.getConstructor$1(contructorName);
   this.method.set$initDelegate(m);
   var other = m;
   while ($notnull_bool($ne(other, null))) {
     if ($notnull_bool($eq(other, this.method))) {
       world.error('initialization cycle', node.span);
@@ skipping 13 matching lines @@
   var args = [];
   var seenLabel = false;
   for (var $i = 0;$i < arguments.length; $i++) {
     var arg = arguments.$index($i);
     if (arg.label != null) {
       seenLabel = true;
     }
     else if ($notnull_bool(seenLabel)) {
       world.error('bare argument can not follow named arguments', arg.get$span());
     }
-    args.add$1(this.visitValue((($0 = arg.get$value()) && $0.is$Expression())));
+    args.add$1(this.visitValue((($0 = arg.get$value()) && $0.is$lang_Expression())));
   }
   return new Arguments(arguments, args);
 }
 MethodGenerator._escapeString = function(text) {
   return text.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('\n', '\\n').replaceAll('\r', '\\r');
 }
 MethodGenerator.prototype.visitStatementsInBlock = function(body) {
   if ((body instanceof BlockStatement)) {
     var block = (body && body.is$BlockStatement());
     var $list = block.body;
@@ skipping 34 matching lines @@
 }
 MethodGenerator.prototype.visitVoid = function(node) {
   if ((node instanceof PostfixExpression)) {
     var value = this.visitPostfixExpression((node && node.is$PostfixExpression()), true);
     value.checkFirstClass$1(node.span);
     return value;
   }
   return this.visitValue(node);
 }
 MethodGenerator.prototype.visitDietStatement = function(node) {
-  var parser = new Parser(node.span.file, false, false, false, node.span.start);
+  var parser = new lang_Parser(node.span.file, false, false, false, node.span.start);
   this.visitStatementsInBlock(parser.block$0());
   return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var $0;
   var isFinal = false;
   if (node.modifiers != null && $notnull_bool($eq(node.modifiers.$index(0).kind, 97/*TokenKind.FINAL*/))) {
     isFinal = true;
   }
   this.writer.write('var ');
   var type = this.method.resolveType(node.type, false);
   for (var i = 0;
    i < node.names.length; i++) {
     var thisType = type;
     if (i > 0) {
       this.writer.write(', ');
     }
     var name = node.names.$index(i).get$name();
-    var value = this.visitValue((($0 = node.values.$index(i)) && $0.is$Expression()));
+    var value = this.visitValue((($0 = node.values.$index(i)) && $0.is$lang_Expression()));
     if ($notnull_bool(isFinal)) {
       if ($notnull_bool(value == null)) {
         world.error('no value specified for final variable', node.span);
       }
       else {
         if ($notnull_bool(thisType.get$isVar())) thisType = value.type;
       }
     }
-    var val = this._scope.create($assert_String(name), (thisType && thisType.is$Type()), node.names.$index(i).get$span(), $assert_bool(isFinal), false);
+    var val = this._scope.create($assert_String(name), (thisType && thisType.is$lang_Type()), node.names.$index(i).get$span(), $assert_bool(isFinal), false);
     if ($notnull_bool(value == null)) {
       if ($notnull_bool(this._scope.reentrant)) {
         this.writer.write(('' + val.code + ' = null'));
       }
       else {
         this.writer.write(('' + val.code + ''));
       }
     }
     else {
       value = value.convertTo$3(this, type, node.values.$index(i));
       this.writer.write(('' + val.code + ' = ' + value.code + ''));
     }
   }
   this.writer.writeln(';');
   return false;
 }
 MethodGenerator.prototype.visitFunctionDefinition = function(node) {
   var $0;
   var name = world.toJsIdentifier(node.name.name);
   var meth = this._makeLambdaMethod($assert_String(name), node);
-  var funcValue = this._scope.create($assert_String(name), (($0 = meth.get$functionType()) && $0.is$Type()), this.method.get$definition().get$span(), true, false);
+  var funcValue = this._scope.create($assert_String(name), (($0 = meth.get$functionType()) && $0.is$lang_Type()), this.method.get$definition().get$span(), true, false);
   meth.generator.writeDefinition$2(this.writer);
   return false;
 }
 MethodGenerator.prototype.visitReturnStatement = function(node) {
   if (node.value == null) {
     this.writer.writeln('return;');
   }
   else {
     if ($notnull_bool(this.method.get$isConstructor())) {
       world.error('return of value not allowed from constructor', node.span);
@@ skipping 93 matching lines @@
     this.writer.write((' ' + test.code + '; '));
   }
   else {
     this.writer.write('; ');
   }
   var needsComma = false;
   var $list = node.step;
   for (var $i = 0;$i < $list.length; $i++) {
     var s = $list.$index($i);
     if ($notnull_bool(needsComma)) this.writer.write(', ');
-    var sv = this.visitVoid((s && s.is$Expression()));
+    var sv = this.visitVoid((s && s.is$lang_Expression()));
     this.writer.write($assert_String(sv.code));
     needsComma = true;
   }
   this.writer.write(') ');
   this._pushBlock(true);
   node.body.visit(this);
   this._popBlock();
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype._isFinal = function(typeRef) {
   if ((typeRef instanceof GenericTypeReference)) {
     typeRef = typeRef.baseType;
   }
   return $notnull_bool($ne(typeRef, null)) && $notnull_bool(typeRef.get$isFinal());
 }
 MethodGenerator.prototype.visitForInStatement = function(node) {
   var $0;
   var itemType = this.method.resolveType(node.item.type, false);
   var itemName = node.item.name.name;
   var list = node.list.visit(this);
   this._pushBlock(true);
   var isFinal = this._isFinal(node.item.type);
-  var item = this._scope.create($assert_String(itemName), (itemType && itemType.is$Type()), node.item.name.span, isFinal, false);
+  var item = this._scope.create($assert_String(itemName), (itemType && itemType.is$lang_Type()), node.item.name.span, isFinal, false);
   var listVar = (list && list.is$Value());
   if ($notnull_bool(list.needsTemp)) {
-    listVar = this._scope.create('\$list', (($0 = list.type) && $0.is$Type()), null, false, false);
+    listVar = this._scope.create('\$list', (($0 = list.type) && $0.is$lang_Type()), null, false, false);
     this.writer.writeln(('var ' + listVar.code + ' = ' + list.code + ';'));
   }
   if ($notnull_bool(list.type.get$isList())) {
     var tmpi = this._scope.create('\$i', world.numType, null, false, false);
     this.writer.enterBlock(('for (var ' + tmpi.code + ' = 0;') + ('' + tmpi.code + ' < ' + listVar.code + '.length; ' + tmpi.code + '++) {'));
     var value = listVar.invoke(this, '\$index', node.list, new Arguments(null, [tmpi]), false);
     this.writer.writeln(('var ' + item.code + ' = ' + value.code + ';'));
   }
   else {
     this._pushBlock(false);
     var iterator = list.invoke$4(this, 'iterator', node.list, Arguments.get$EMPTY());
-    var tmpi = this._scope.create('\$i', (($0 = iterator.type) && $0.is$Type()), null, false, false);
+    var tmpi = this._scope.create('\$i', (($0 = iterator.type) && $0.is$lang_Type()), null, false, false);
     var hasNext = tmpi.invoke$4(this, 'hasNext', node.list, Arguments.get$EMPTY());
     var next = tmpi.invoke$4(this, 'next', node.list, Arguments.get$EMPTY());
     this.writer.enterBlock(('for (var ' + tmpi.code + ' = ' + iterator.code + '; ' + hasNext.code + '; ) {'));
     this.writer.writeln(('var ' + item.code + ' = ' + next.code + ';'));
   }
   this.visitStatementsInBlock(node.body);
   this.writer.exitBlock('}');
   this._popBlock();
   return false;
 }
@@ skipping 25 matching lines @@
     if (catch_.trace != null) {
       var trace = this._scope.declare(catch_.trace);
       this.writer.writeln(('var ' + trace.code + ' = \$stackTraceOf(' + ex.code + ');'));
       world.gen.corejs.useStackTraceOf = true;
     }
     this._genToDartException($assert_String(ex.code), node);
     if (!$notnull_bool(ex.type.get$isVarOrObject())) {
       var test = ex.instanceOf$3$isTrue$forceCheck(this, ex.type, catch_.get$exception().get$span(), false, true);
       this.writer.writeln(('if (' + test.code + ') throw ' + ex.code + ';'));
     }
-    this.visitStatementsInBlock((($0 = node.catches.$index(0).body) && $0.is$Statement()));
+    this.visitStatementsInBlock((($0 = node.catches.$index(0).body) && $0.is$lang_Statement()));
     this._popBlock();
   }
   else if (node.catches.length > 0) {
     this._pushBlock(false);
     var ex = this._scope.create('\$ex', world.varType, null, false, false);
     this._scope.rethrow = (ex && ex.is$Value());
     this.writer.nextBlock(('} catch (' + ex.code + ') {'));
     var trace = null;
     if (node.catches.some((function (c) {
       return c.trace != null;
@@ skipping 20 matching lines @@
         }
       }
       else if (i > 0) {
         this.writer.nextBlock('} else {');
       }
       this.writer.writeln(('var ' + tmp.code + ' = ' + ex.code + ';'));
       if (catch_.trace != null) {
         var tmptrace = this._scope.declare(catch_.trace);
         this.writer.writeln(('var ' + tmptrace.code + ' = ' + trace.code + ';'));
       }
-      this.visitStatementsInBlock((($0 = catch_.body) && $0.is$Statement()));
+      this.visitStatementsInBlock((($0 = catch_.body) && $0.is$lang_Statement()));
       this._popBlock();
       if ($notnull_bool(tmp.type.get$isVarOrObject())) {
         if (i + 1 < node.catches.length) {
           world.warning('Unreachable catch clause', (($0 = node.catches.$index(i + 1)) && $0.is$SourceSpan()));
         }
         if (i > 0) {
           this.writer.exitBlock('}');
         }
         needsRethrow = false;
         break;
@@ skipping 28 matching lines @@
     for (var i = 0;
      i < case_.cases.length; i++) {
       var expr = case_.cases.$index(i);
       if ($notnull_bool(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 && expr.is$Expression()));
+        var value = this.visitValue((expr && expr.is$lang_Expression()));
         this.writer.writeln(('case ' + value.code + ':'));
       }
     }
     this.writer.enterBlock('');
     var caseExits = this._visitAllStatements(case_.statements, false);
     if ($notnull_bool($ne(case_, node.cases.$index(node.cases.length - 1))) && !$notnull_bool(caseExits)) {
       var span = case_.statements.$index(case_.statements.length - 1).get$span();
       this.writer.writeln('\$throw(new FallThroughError());');
       world.gen.corejs.useThrow = true;
     }
@@ skipping 288 matching lines @@
   switch (node.op.kind) {
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
       if ($notnull_bool(value.type.get$isNum())) {
         return new Value(value.type, ('' + node.op + '' + value.code + ''), node.span, true);
       }
       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($assert_num(kind), node.self, (operand && operand.is$Expression()), node, to$call$1(null));
+        return this._visitAssign($assert_num(kind), node.self, (operand && operand.is$lang_Expression()), node, to$call$1(null));
       }
 
     case 19/*TokenKind.NOT*/:
 
       if ($notnull_bool(value.type.get$isBool()) && $notnull_bool(value.get$isConst())) {
         var newVal = !$notnull_bool(value.get$actualValue());
-        return EvaluatedValue.EvaluatedValue$factory((($0 = value.type) && $0.is$Type()), newVal, ('' + newVal + ''), node.span);
+        return EvaluatedValue.EvaluatedValue$factory((($0 = value.type) && $0.is$lang_Type()), newVal, ('' + newVal + ''), node.span);
       }
       else {
         var newVal = value.convertTo$3(this, world.nonNullBool, node);
         return new Value(newVal.type, ('!' + newVal.code + ''), node.span, true);
       }
 
     case 42/*TokenKind.ADD*/:
 
       return value.convertTo$3(this, world.numType, node);
 
@@ skipping 19 matching lines @@
 }
 MethodGenerator.prototype.visitPostfixExpression = function(node, isVoid) {
   var $this = this; // closure support
   var value = this.visitValue(node.body);
   if ($notnull_bool(value.type.get$isNum())) {
     return new Value(value.type, ('' + value.code + '' + node.op + ''), node.span, true);
   }
   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);
   var tmpleft = null, left = null;
-  var ret = this._visitAssign($assert_num(kind), node.body, (operand && operand.is$Expression()), node, (function (l) {
+  var ret = this._visitAssign($assert_num(kind), node.body, (operand && operand.is$lang_Expression()), node, (function (l) {
     if ($notnull_bool(isVoid)) {
       return l;
     }
     else {
       left = l;
       tmpleft = $this.forceTemp((l && l.is$Value()));
       return $this.assignTemp((tmpleft && tmpleft.is$Value()), (left && left.is$Value()));
     }
   })
   );
@@ skipping 32 matching lines @@
     world.error(('no matching constructor for ' + name + ''), node.span);
     return this._makeMissingValue($assert_String(name));
   }
   if ($notnull_bool(node.isConst)) {
     if (!$notnull_bool(m.get$isConst())) {
       world.error('can\'t use const on a non-const constructor', node.span);
     }
     var $list = node.arguments;
     for (var $i = 0;$i < $list.length; $i++) {
       var arg = $list.$index($i);
-      if (!$notnull_bool(this.visitValue((($0 = arg.get$value()) && $0.is$Expression())).get$isConst())) {
+      if (!$notnull_bool(this.visitValue((($0 = arg.get$value()) && $0.is$lang_Expression())).get$isConst())) {
         world.error('const constructor expects const arguments', arg.get$span());
       }
     }
   }
   return m.invoke$4(this, node, null, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitListExpression = function(node) {
   var argsCode = [];
   var argValues = [];
   var $list = node.values;
   for (var $i = 0;$i < $list.length; $i++) {
     var item = $list.$index($i);
-    var arg = this.visitValue((item && item.is$Expression()));
+    var arg = this.visitValue((item && item.is$lang_Expression()));
     argValues.add$1(arg);
     if ($notnull_bool(node.isConst)) {
       if (!$notnull_bool(arg.get$isConst())) {
         world.error('const list can only contain const values', item.get$span());
         argsCode.add$1(arg.code);
       }
       else {
         argsCode.add$1(arg.get$canonicalCode());
       }
     }
     else {
       argsCode.add$1(arg.code);
     }
   }
   world.get$coreimpl().types.$index('ListFactory').markUsed$0();
   var code = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
   var value = new Value(world.listType, code, node.span, true);
   if ($notnull_bool(node.isConst)) {
     var immutableList = world.get$coreimpl().types.$index('ImmutableList');
     var immutableListCtor = immutableList.getConstructor$1('from');
     var result = immutableListCtor.invoke$4(this, node, null, new Arguments(null, [value]));
-    value = world.gen.globalForConst(ConstListValue.ConstListValue$factory((immutableList && immutableList.is$Type()), (argValues && argValues.is$List$EvaluatedValue()), ('const ' + code + ''), $assert_String(result.code), node.span), (argValues && argValues.is$List$Value()));
+    value = world.gen.globalForConst(ConstListValue.ConstListValue$factory((immutableList && immutableList.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), ('const ' + code + ''), $assert_String(result.code), node.span), (argValues && argValues.is$List$Value()));
   }
   return value;
 }
 MethodGenerator.prototype.visitMapExpression = function(node) {
   var $0;
   var mapImplType = world.gen.useMapFactory();
   var argValues = [];
   var argsCode = [];
   for (var i = 0;
    i < node.items.length; i += 2) {
-    var key = this.visitTypedValue((($0 = node.items.$index(i)) && $0.is$Expression()), world.stringType);
+    var key = this.visitTypedValue((($0 = node.items.$index(i)) && $0.is$lang_Expression()), world.stringType);
     var valueItem = node.items.$index(i + 1);
-    var value = this.visitValue((valueItem && valueItem.is$Expression()));
+    var value = this.visitValue((valueItem && valueItem.is$lang_Expression()));
     argValues.add$1(key);
     argValues.add$1(value);
     if ($notnull_bool(node.isConst)) {
       if (!$notnull_bool(key.get$isConst()) || !$notnull_bool(value.get$isConst())) {
         world.error('const map can only contain const values', valueItem.get$span());
         argsCode.add$1(key.code);
         argsCode.add$1(value.code);
       }
       else {
         argsCode.add$1(key.get$canonicalCode());
         argsCode.add$1(value.get$canonicalCode());
       }
     }
     else {
       argsCode.add$1(key.code);
       argsCode.add$1(value.code);
     }
   }
   var argList = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
   var code = ('\$map(' + argList + ')');
   if ($notnull_bool(node.isConst)) {
     var immutableMap = world.get$coreimpl().types.$index('ImmutableMap');
     var immutableMapCtor = immutableMap.getConstructor$1('');
     var argsValue = new Value(world.listType, argList, node.span, true);
     var result = immutableMapCtor.invoke$4(this, node, null, new Arguments(null, [argsValue]));
-    var value = ConstMapValue.ConstMapValue$factory((immutableMap && immutableMap.is$Type()), (argValues && argValues.is$List$EvaluatedValue()), code, $assert_String(result.code), node.span);
+    var value = ConstMapValue.ConstMapValue$factory((immutableMap && immutableMap.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), code, $assert_String(result.code), node.span);
     return world.gen.globalForConst(value, (argValues && argValues.is$List$Value()));
   }
   return new Value(mapImplType, code, node.span, true);
 }
 MethodGenerator.prototype.visitConditionalExpression = function(node) {
   var $0;
   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(Type.union((($0 = trueBranch.type) && $0.is$Type()), (($0 = falseBranch.type) && $0.is$Type())), code, node.span, true);
+  return new Value(lang_Type.union((($0 = trueBranch.type) && $0.is$lang_Type()), (($0 = falseBranch.type) && $0.is$lang_Type())), code, node.span, true);
 }
 MethodGenerator.prototype.visitIsExpression = function(node) {
   var value = this.visitValue(node.x);
   var type = this.method.resolveType(node.type, false);
   return value.instanceOf$4(this, type, node.span, node.isTrue);
 }
 MethodGenerator.prototype.visitParenExpression = function(node) {
   var $0;
   var body = this.visitValue(node.body);
   if ($notnull_bool(body.get$isConst())) {
-    return EvaluatedValue.EvaluatedValue$factory((($0 = body.type) && $0.is$Type()), body.get$actualValue(), ('(' + body.get$canonicalCode() + ')'), node.span);
+    return EvaluatedValue.EvaluatedValue$factory((($0 = body.type) && $0.is$lang_Type()), body.get$actualValue(), ('(' + body.get$canonicalCode() + ')'), node.span);
   }
   return new Value(body.type, ('(' + body.code + ')'), node.span, true);
 }
 MethodGenerator.prototype.visitDotExpression = function(node) {
   var target = node.self.visit(this);
   return target.get_$3(this, node.name.name, node.name);
 }
 MethodGenerator.prototype.visitVarExpression = function(node) {
   var name = node.name.name;
   var ret = this._scope.lookup(name);
@@ skipping 18 matching lines @@
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   var $0;
   var type = node.type.type;
   $assert($ne(type, null), "type != null", "gen.dart", 2119, 12);
   if (!!(($0 = node.value) && $0.is$List)) {
     var items = [];
     var $list = node.value;
     for (var $i = node.value.iterator$0(); $i.hasNext$0(); ) {
       var item = $i.next$0();
-      var val = this.visitValue((item && item.is$Expression()));
+      var val = this.visitValue((item && item.is$lang_Expression()));
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
       var code = val.code;
       if ((item instanceof BinaryExpression) || (item instanceof ConditionalExpression)) {
         code = ('(' + code + ')');
       }
       items.add$1(code);
     }
     return new Value(type, ('(' + Strings.join((items && items.is$List$String()), " + ") + ')'), node.span, true);
   }
   var text = node.text;
   if ($notnull_bool(type.get$isString())) {
     if ($notnull_bool(text.startsWith$1('@'))) {
       text = MethodGenerator._escapeString(parseStringLiteral($assert_String(text)));
       text = ('"' + text + '"');
     }
     else if ($notnull_bool(isMultilineString($assert_String(text)))) {
       text = parseStringLiteral($assert_String(text));
       text = text.replaceAll$2('\n', '\\n');
       text = text.replaceAll$2('"', '\\"');
       text = ('"' + text + '"');
     }
     if (text !== node.text) {
       node.value = text;
       node.text = $assert_String(text);
     }
   }
-  return EvaluatedValue.EvaluatedValue$factory((type && type.is$Type()), node.value, node.text, null);
+  return EvaluatedValue.EvaluatedValue$factory((type && type.is$lang_Type()), node.value, node.text, null);
 }
 MethodGenerator.prototype.visitPostfixExpression$1 = function($0) {
   return this.visitPostfixExpression(($0 && $0.is$PostfixExpression()), false);
 };
 MethodGenerator.prototype.writeDefinition$2 = function($0, $1) {
   return this.writeDefinition(($0 && $0.is$CodeWriter()), ($1 && $1.is$LambdaExpression()));
 };
 // ********** Code for Arguments **************
 function Arguments(nodes, values) {
   this.nodes = nodes;
@@ skipping 239 matching lines @@
     }
     if ($notnull_bool($ne(newRet, null))) {
       if ($notnull_bool($ne(ret, null)) && $notnull_bool($ne(ret, newRet))) {
         world.error(('conflicting types for "' + name + '"'), ret.get$span(), newRet.get$span());
       }
       else {
         ret = newRet;
       }
     }
   }
-  return (ret && ret.is$Type());
+  return (ret && ret.is$lang_Type());
 }
 Library.prototype.lookup = function(name, span) {
   var retType = this.findTypeByName(name);
   var ret = null;
   if ($notnull_bool($ne(retType, null))) {
     ret = retType.get$typeMember();
   }
   var newRet = this.topType.getMember(name);
   if ($notnull_bool($ne(newRet, null))) {
     if ($notnull_bool($ne(ret, null)) && $notnull_bool($ne(ret, newRet))) {
@@ skipping 88 matching lines @@
 _LibraryVisitor.prototype.addSource = function(source) {
   var $this = this; // closure support
   if (this.library.sources.some((function (s) {
     return s.filename == source.filename;
   })
   )) {
     world.error(('duplicate source file "' + source.filename + '"'));
     return;
   }
   this.library.sources.add(source);
-  var parser = new Parser(source, options.dietParse, false, false, 0);
+  var parser = new lang_Parser(source, options.dietParse, false, false, 0);
   var unit = parser.compilationUnit();
   unit.forEach((function (def) {
     return def.visit$1($this);
   })
   );
   $assert(this.sources.length == 0 || $notnull_bool(this.isTop), "sources.length == 0 || isTop", "library.dart", 293, 12);
   this.isTop = false;
   var newSources = this.sources;
   this.sources = [];
   for (var $i = newSources.iterator$0(); $i.hasNext$0(); ) {
@@ skipping 195 matching lines @@
   var ret = new Parameter(this.definition);
   ret.set$type(newType);
   ret.set$name(this.name);
   ret.isInitializer = this.isInitializer;
   return (ret && ret.is$Parameter());
 }
 Parameter.prototype.get$isOptional = function() {
   return this.definition != null && this.definition.value != null;
 }
 Parameter.prototype.copyWithNewType$1 = function($0) {
-  return this.copyWithNewType(($0 && $0.is$Type()));
+  return this.copyWithNewType(($0 && $0.is$lang_Type()));
 };
 Parameter.prototype.genValue$2 = function($0, $1) {
   return this.genValue(($0 && $0.is$MethodMember()), ($1 && $1.is$MethodGenerator()));
 };
 Parameter.prototype.resolve$2 = function($0, $1) {
-  return this.resolve(($0 && $0.is$Member()), ($1 && $1.is$Type()));
+  return this.resolve(($0 && $0.is$Member()), ($1 && $1.is$lang_Type()));
 };
 // ********** Code for Member **************
 function Member(name, declaringType) {
   this.name = name;
   this.declaringType = declaringType;
   this.isGenerated = false;
   // Initializers done
 }
 Member.prototype.is$Member = function(){return this;};
 Member.prototype.is$Named = function(){return this;};
@@ skipping 59 matching lines @@
   world.internalError('cannot have initializers', this.get$span());
 }
 Member.prototype.set$initDelegate = function(ctor) {
   world.internalError('cannot have initializers', this.get$span());
 }
 Member.prototype.get$inferredResult = function() {
   var t = this.get$returnType();
   if ($notnull_bool(t.get$isBool()) && ($notnull_bool(this.get$library().get$isCore()) || $notnull_bool(this.get$library().get$isCoreImpl()))) {
     return world.nonNullBool;
   }
-  return (t && t.is$Type());
+  return (t && t.is$lang_Type());
 }
 Member.prototype.get$definition = function() {
   return null;
 }
 Member.prototype.get$parameters = function() {
   return [];
 }
 Member.prototype.canInvoke = function(context, args) {
   return $notnull_bool(this.get$canGet()) && $notnull_bool(new Value(this.get$returnType(), null, null, true).canInvoke(context, '\$call', args));
 }
@@ skipping 21 matching lines @@
   }
   else {
     return ('' + prefix + '' + this.name + '\$factory');
   }
 }
 Member.prototype.resolveType = function(node, isRequired) {
   var type = this.declaringType.resolveType(node, isRequired);
   if ($notnull_bool(this.get$isStatic()) && $notnull_bool(type.get$hasTypeParams())) {
     world.error('using type parameter in static context', node.span);
   }
-  return (type && type.is$Type());
+  return (type && type.is$lang_Type());
 }
 Member.prototype._get$3 = function($0, $1, $2) {
-  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()));
+  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()));
 };
 Member.prototype._set$4 = function($0, $1, $2, $3) {
-  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()));
+  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()));
 };
 Member.prototype.canInvoke$2 = function($0, $1) {
   return this.canInvoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Arguments()));
 };
 Member.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 };
 Member.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 Member.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
 Member.prototype.provideFieldSyntax$0 = function() {
   return this.provideFieldSyntax();
 };
 Member.prototype.providePropertySyntax$0 = function() {
   return this.providePropertySyntax();
 };
 Member.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$Type()));
+  return this.resolve(($0 && $0.is$lang_Type()));
 };
 // ********** Code for TypeMember **************
 function TypeMember(type) {
   this.type = type;
   // Initializers done
   Member.call(this, type.name, type.library.topType);
 }
 $inherits(TypeMember, Member);
 TypeMember.prototype.is$TypeMember = function(){return this;};
 TypeMember.prototype.get$type = function() { return this.type; };
@@ skipping 23 matching lines @@
   ret.isType = true;
   return (ret && ret.is$Value());
 }
 TypeMember.prototype._set = function(context, node, target, value, isDynamic) {
   world.error('can not set type', node.span);
 }
 TypeMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   world.error('can not invoke type', node.span);
 }
 TypeMember.prototype._get$3 = function($0, $1, $2) {
-  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), false);
+  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 TypeMember.prototype._set$4 = function($0, $1, $2, $3) {
-  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
+  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 TypeMember.prototype.canInvoke$2 = function($0, $1) {
   return this.canInvoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Arguments()));
 };
 TypeMember.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 };
 TypeMember.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 TypeMember.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
 TypeMember.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$Type()));
+  return this.resolve(($0 && $0.is$lang_Type()));
 };
 // ********** Code for FieldMember **************
 function FieldMember(name, declaringType, definition, value) {
   this._providePropertySyntax = false
   this._computing = false
   this.definition = definition;
   this.value = value;
   this.isNative = false;
   // Initializers done
   Member.call(this, name, declaringType);
@@ skipping 136 matching lines @@
     }
   }
   return new Value(this.type, ('' + target.code + '.' + this.get$jsname() + ''), node.span, true);
 }
 FieldMember.prototype._set = function(context, node, target, value, isDynamic) {
   var lhs = this._get(context, node, target, isDynamic);
   value = value.convertTo(context, this.type, node, isDynamic);
   return new Value(this.type, ('' + lhs.code + ' = ' + value.code + ''), node.span, true);
 }
 FieldMember.prototype._get$3 = function($0, $1, $2) {
-  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), false);
+  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 FieldMember.prototype._set$4 = function($0, $1, $2, $3) {
-  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
+  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 FieldMember.prototype.computeValue$0 = function() {
   return this.computeValue();
 };
 FieldMember.prototype.provideFieldSyntax$0 = function() {
   return this.provideFieldSyntax();
 };
 FieldMember.prototype.providePropertySyntax$0 = function() {
   return this.providePropertySyntax();
 };
 FieldMember.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$Type()));
+  return this.resolve(($0 && $0.is$lang_Type()));
 };
 // ********** Code for PropertyMember **************
 function PropertyMember(name, declaringType) {
   this._provideFieldSyntax = false
   // Initializers done
   Member.call(this, name, declaringType);
 }
 $inherits(PropertyMember, Member);
 PropertyMember.prototype.is$PropertyMember = function(){return this;};
 PropertyMember.prototype.get$span = function() {
@@ skipping 69 matching lines @@
   }
   if (this.getter == null) this.getter = parent.getter;
   if (this.setter == null) this.setter = parent.setter;
 }
 PropertyMember.prototype.resolve = function(inType) {
   if (this.getter != null) this.getter.resolve(inType);
   if (this.setter != null) this.setter.resolve(inType);
   this.get$library()._addMember(this);
 }
 PropertyMember.prototype._get$3 = function($0, $1, $2) {
-  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), false);
+  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 PropertyMember.prototype._set$4 = function($0, $1, $2, $3) {
-  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
+  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 PropertyMember.prototype.provideFieldSyntax$0 = function() {
   return this.provideFieldSyntax();
 };
 PropertyMember.prototype.providePropertySyntax$0 = function() {
   return this.providePropertySyntax();
 };
 PropertyMember.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$Type()));
+  return this.resolve(($0 && $0.is$lang_Type()));
 };
 // ********** Code for ConcreteMember **************
 function ConcreteMember(name, declaringType, baseMember) {
   this.baseMember = baseMember;
   // Initializers done
   Member.call(this, name, declaringType);
   this.parameters = [];
   this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType);
   var $list = this.baseMember.get$parameters();
   for (var $i = 0;$i < $list.length; $i++) {
@@ skipping 76 matching lines @@
 }
 ConcreteMember.prototype.get$initDelegate = function() {
   return this.baseMember.get$initDelegate();
 }
 ConcreteMember.prototype.set$initDelegate = function(ctor) {
   this.baseMember.set$initDelegate(ctor);
 }
 ConcreteMember.prototype.resolveType = function(node, isRequired) {
   var $0;
   var type = this.baseMember.resolveType(node, isRequired);
-  return (($0 = type.resolveTypeParams$1(this.declaringType)) && $0.is$Type());
+  return (($0 = type.resolveTypeParams$1(this.declaringType)) && $0.is$lang_Type());
 }
 ConcreteMember.prototype.override = function(other) {
   return this.baseMember.override(other);
 }
 ConcreteMember.prototype._get = function(context, node, target, isDynamic) {
   var ret = this.baseMember._get(context, node, target, isDynamic);
   return new Value(this.get$inferredResult(), ret.code, node.span, true);
 }
 ConcreteMember.prototype._set = function(context, node, target, value, isDynamic) {
   var ret = this.baseMember._set(context, node, target, value, isDynamic);
   return new Value(this.returnType, ret.code, node.span, true);
 }
 ConcreteMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   var ret = this.baseMember.invoke(context, node, target, args, isDynamic);
   var code = ret.code;
   if ($notnull_bool(this.get$isConstructor())) {
     code = code.replaceFirst$2(this.declaringType.get$genericType().get$jsname(), this.declaringType.get$jsname());
   }
   if ((this.baseMember instanceof MethodMember)) {
     this.declaringType.genMethod(this);
   }
   return new Value(this.get$inferredResult(), code, node.span, true);
 }
 ConcreteMember.prototype._get$3 = function($0, $1, $2) {
-  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), false);
+  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 ConcreteMember.prototype._set$4 = function($0, $1, $2, $3) {
-  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
+  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 ConcreteMember.prototype.canInvoke$2 = function($0, $1) {
   return this.canInvoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Arguments()));
 };
 ConcreteMember.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 };
 ConcreteMember.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 ConcreteMember.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
 ConcreteMember.prototype.provideFieldSyntax$0 = function() {
   return this.provideFieldSyntax();
 };
 ConcreteMember.prototype.providePropertySyntax$0 = function() {
   return this.providePropertySyntax();
 };
 // ********** Code for MethodMember **************
 function MethodMember(name, declaringType, definition) {
   this.isStatic = false
@@ skipping 299 matching lines @@
   return new Value(this.get$inferredResult(), code, node.span, true);
 }
 MethodMember.prototype._invokeConstructor = function(context, node, target, args, argsString) {
   this.declaringType.markUsed();
   if (target != null) {
     var code = (this.get$constructorName() != '') ? ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor.call(' + argsString + ')') : ('' + this.declaringType.get$jsname() + '.call(' + argsString + ')');
     return new Value(this.declaringType, code, node.span, true);
   }
   else {
     var code = (this.get$constructorName() != '') ? ('new ' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor(' + argsString + ')') : ('new ' + this.declaringType.get$jsname() + '(' + argsString + ')');
-    if ($notnull_bool(this.isConst) && (node instanceof NewExpression) && $notnull_bool(node.get$dynamic().get$isConst())) {
+    if ($notnull_bool(this.isConst) && (node instanceof lang_NewExpression) && $notnull_bool(node.get$dynamic().get$isConst())) {
       return this._invokeConstConstructor(node, $assert_String(code), target, args);
     }
     else {
       return new Value(this.declaringType, code, node.span, true);
     }
   }
 }
 MethodMember.prototype._invokeConstConstructor = function(node, code, target, args) {
   var $0;
   var fields = new HashMapImplementation();
@@ skipping 346 matching lines @@
     var formal = $list.$index($i);
     var param = new Parameter(formal);
     param.resolve$2(this, inType);
     this.parameters.add(param);
   }
   if (!$notnull_bool(this.isLambda)) {
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype._get$3 = function($0, $1, $2) {
-  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), false);
+  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 MethodMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), $1, ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 MethodMember.prototype.canInvoke$2 = function($0, $1) {
   return this.canInvoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Arguments()));
 };
 MethodMember.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 };
 MethodMember.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 MethodMember.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
 MethodMember.prototype.namesInOrder$1 = function($0) {
   return this.namesInOrder(($0 && $0.is$Arguments()));
 };
 MethodMember.prototype.provideFieldSyntax$0 = function() {
   return this.provideFieldSyntax();
 };
 MethodMember.prototype.providePropertySyntax$0 = function() {
   return this.providePropertySyntax();
 };
 MethodMember.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$Type()));
+  return this.resolve(($0 && $0.is$lang_Type()));
 };
 // ********** Code for MemberSet **************
 function MemberSet(member, isVar) {
   this.name = member.name;
   this.members = [member];
   this.jsname = member.get$jsname();
   this.isVar = isVar;
   // Initializers done
 }
 MemberSet.prototype.is$MemberSet = function(){return this;};
@@ skipping 112 matching lines @@
     if ($notnull_bool(this.get$treatAsField())) {
       return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ' = ' + value.code + ''), node.span, true);
     }
     else {
       return new Value(returnValue.type, ('' + target.code + '.set\$' + this.jsname + '(' + value.code + ')'), node.span, true);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invoke = function(context, node, target, args, isDynamic) {
+  var $0;
   if ($notnull_bool(this.isVar) && !$notnull_bool(this.get$isOperator())) {
     return this.invokeOnVar(context, node, target, args);
   }
   if (this.members.length == 1) {
-    return this.members.$index(0).invoke$5(context, node, target, args, isDynamic);
+    return (($0 = this.members.$index(0).invoke$5(context, node, target, args, isDynamic)) && $0.is$Value());
   }
   var targets = this.members.filter((function (m) {
     return m.canInvoke$2(context, args);
   })
   );
   if (targets.length == 1) {
-    return targets.$index(0).invoke$5(context, node, target, args, isDynamic);
+    return (($0 = targets.$index(0).invoke$5(context, node, target, args, isDynamic)) && $0.is$Value());
   }
   var returnValue = null;
   for (var $i = targets.iterator$0(); $i.hasNext$0(); ) {
     var member = $i.next$0();
     var res = member.invoke$4$isDynamic(context, node, target, args, true);
-    returnValue = this._tryUnion(returnValue, res, node);
+    returnValue = this._tryUnion(returnValue, (res && res.is$Value()), node);
   }
   if (returnValue == null) {
     return this._makeError(node, target, 'method');
   }
   if (returnValue.code == null) {
     if (this.name == '\$call') {
       return target._varCall(context, args);
     }
     else if ($notnull_bool(this.get$isOperator())) {
       return target.invokeSpecial(this.name, args, returnValue.type);
     }
     else {
       return this.invokeOnVar(context, node, target, args);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invokeOnVar = function(context, node, target, args) {
   var member = this.getVarMember(context, node, args);
   return member.invoke$4(context, node, target, args);
 }
 MemberSet.prototype._tryUnion = function(x, y, node) {
   if (x == null) return y;
-  var type = Type.union(x.type, y.type);
+  var type = lang_Type.union(x.type, y.type);
   if (x.code == y.code) {
     if ($notnull_bool($eq(type, x.type))) {
       return x;
     }
     else if ($notnull_bool(x.get$isConst()) || $notnull_bool(y.get$isConst())) {
       world.internalError("unexpected: union of const values ");
     }
     else {
       var ret = new Value(type, x.code, node.span, true);
       ret.isSuper = $notnull_bool(x.isSuper) && $notnull_bool(y.isSuper);
@@ skipping 14 matching lines @@
   var stub = world.objectType.varStubs.$index(stubName);
   if ($notnull_bool(stub == null)) {
     var mset = context.findMembers(this.name).members;
     var targets = mset.filter((function (m) {
       return m.canInvoke$2(context, args);
     })
     );
     var returnType = reduce(map((targets && targets.is$Iterable()), (function (t) {
       return t.get$returnType();
     })
-    ), Type.union);
+    ), lang_Type.union);
     stub = new VarMethodSet($assert_String(stubName), targets, args, returnType);
     world.objectType.varStubs.$setindex(stubName, stub);
   }
   return (stub && stub.is$VarMember());
 }
 MemberSet.prototype._get$3 = function($0, $1, $2) {
-  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), false);
+  return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 MemberSet.prototype._set$4 = function($0, $1, $2, $3) {
-  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
+  return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 MemberSet.prototype.add$1 = function($0) {
   return this.add(($0 && $0.is$Member()));
 };
 MemberSet.prototype.canInvoke$2 = function($0, $1) {
   return this.canInvoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Arguments()));
 };
 MemberSet.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 };
 MemberSet.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 MemberSet.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
 MemberSet.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for FactoryMap **************
 function FactoryMap() {
   this.factories = $map([]);
   // Initializers done
 }
 FactoryMap.prototype.getFactoriesFor = function(typeName) {
@@ skipping 16 matching lines @@
     constructors.forEach((function (_, member) {
       f(member);
     })
     );
   })
   );
 }
 FactoryMap.prototype.getFactory$2 = function($0, $1) {
   return this.getFactory($assert_String($0), $assert_String($1));
 };
-// ********** Code for Token **************
-function Token(kind, source, start, end) {
+// ********** Code for lang_Token **************
+function lang_Token(kind, source, start, end) {
   this.kind = kind;
   this.source = source;
   this.start = start;
   this.end = end;
   // Initializers done
 }
-Token.prototype.get$source = function() { return this.source; };
-Token.prototype.get$text = function() {
+lang_Token.prototype.get$source = function() { return this.source; };
+lang_Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
 }
-Token.prototype.toString = function() {
+lang_Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
   if ($notnull_bool($ne(kindText, actualText))) {
     if (actualText.length > 10) {
       actualText = actualText.substring$2(0, 8) + '...';
     }
     return ('' + kindText + '(' + actualText + ')');
   }
   else {
     return $assert_String(kindText);
   }
 }
-Token.prototype.get$span = function() {
+lang_Token.prototype.get$span = function() {
   return new SourceSpan(this.source, this.start, this.end);
 }
-Token.prototype.toString$0 = function() {
+lang_Token.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for SourceFile **************
 function SourceFile(filename, _text) {
   this.filename = filename;
   this._text = _text;
   // Initializers done
 }
 SourceFile.prototype.is$SourceFile = function(){return this;};
 SourceFile.prototype.is$Comparable = function(){return this;};
@@ skipping 145 matching lines @@
     }
     else {
       return false;
     }
   }
   else {
     return false;
   }
 }
 TokenizerBase.prototype._finishToken = function(kind) {
-  return new Token(kind, this._source, this._startIndex, this._lang_index);
+  return new lang_Token(kind, this._source, this._startIndex, this._lang_index);
 }
 TokenizerBase.prototype._errorToken = function() {
   return this._finishToken(65/*TokenKind.ERROR*/);
 }
 TokenizerBase.prototype.finishWhitespace = function() {
   while (this._lang_index < this._text.length) {
     if (!$notnull_bool(TokenizerHelpers.isWhitespace(this._text.charCodeAt(this._lang_index++)))) {
       this._lang_index--;
       if ($notnull_bool(this._skipWhitespace)) {
         return this.next();
@@ skipping 240 matching lines @@
         else {
           return false;
         }
       }
 
     default:
 
       return true;
 
   }
-  var n = Parser.parseHex(hex);
+  var n = lang_Parser.parseHex(hex);
   return n < 0xD800 || n > 0xDFFF && n <= 0x10FFFF;
 }
 TokenizerBase.prototype.finishDot = function() {
   if ($notnull_bool(TokenizerHelpers.isDigit(this._peekChar()))) {
     this.eatDigits();
     return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
   }
   else {
     return this._finishToken(14/*TokenKind.DOT*/);
   }
@@ skipping 1365 matching lines @@
 
   }
 }
 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 -1;
 }
-// ********** Code for Parser **************
-function Parser(source, diet, throwOnIncomplete, optionalSemicolons, startOffset) {
+// ********** Code for lang_Parser **************
+function lang_Parser(source, diet, throwOnIncomplete, optionalSemicolons, startOffset) {
   this.source = source;
   this.diet = diet;
   this.throwOnIncomplete = throwOnIncomplete;
   this.optionalSemicolons = optionalSemicolons;
   // Initializers done
   this.tokenizer = new Tokenizer(this.source, true, startOffset);
   this._peekToken = this.tokenizer.next();
   this._previousToken = null;
   this._inInitializers = false;
 }
-Parser.prototype.get$source = function() { return this.source; };
-Parser.prototype.isPrematureEndOfFile = function() {
+lang_Parser.prototype.get$source = function() { return this.source; };
+lang_Parser.prototype.isPrematureEndOfFile = function() {
   if ($notnull_bool(this.throwOnIncomplete) && $notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/)) || $notnull_bool(this._maybeEat(68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/)) || $notnull_bool(this._maybeEat(69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/))) {
     $throw(new IncompleteSourceException(this._previousToken));
   }
   else if ($notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/))) {
     this._lang_error('unexpected end of file', this._peekToken.get$span());
     return true;
   }
   else {
     return false;
   }
 }
-Parser.prototype._peek = function() {
+lang_Parser.prototype._peek = function() {
   return this._peekToken.kind;
 }
-Parser.prototype._lang_next = function() {
+lang_Parser.prototype._lang_next = function() {
   this._previousToken = this._peekToken;
   this._peekToken = this.tokenizer.next();
   return this._previousToken;
 }
-Parser.prototype._peekKind = function(kind) {
+lang_Parser.prototype._peekKind = function(kind) {
   return this._peekToken.kind == kind;
 }
-Parser.prototype._peekIdentifier = function() {
+lang_Parser.prototype._peekIdentifier = function() {
   return TokenKind.isIdentifier(this._peekToken.kind);
 }
-Parser.prototype._maybeEat = function(kind) {
+lang_Parser.prototype._maybeEat = function(kind) {
   if (this._peekToken.kind == kind) {
     this._previousToken = this._peekToken;
     this._peekToken = this.tokenizer.next();
     return true;
   }
   else {
     return false;
   }
 }
-Parser.prototype._eat = function(kind) {
+lang_Parser.prototype._eat = function(kind) {
   if (!$notnull_bool(this._maybeEat(kind))) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
 }
-Parser.prototype._eatSemicolon = function() {
+lang_Parser.prototype._eatSemicolon = function() {
   if ($notnull_bool(this.optionalSemicolons) && $notnull_bool(this._peekKind(1/*TokenKind.END_OF_FILE*/))) return;
   this._eat(10/*TokenKind.SEMICOLON*/);
 }
-Parser.prototype._errorExpected = function(expected) {
+lang_Parser.prototype._errorExpected = function(expected) {
   if ($notnull_bool(this.throwOnIncomplete)) this.isPrematureEndOfFile();
   var tok = this._lang_next();
   var message = ('expected ' + expected + ', but found ' + tok + '');
   this._lang_error($assert_String(message), tok.get$span());
 }
-Parser.prototype._lang_error = function(message, location) {
+lang_Parser.prototype._lang_error = function(message, location) {
   if (location == null) {
     location = this._peekToken.get$span();
   }
   world.fatal(message, location);
 }
-Parser.prototype._skipBlock = function() {
+lang_Parser.prototype._skipBlock = function() {
   var depth = 1;
   this._eat(6/*TokenKind.LBRACE*/);
   while (true) {
     var tok = this._lang_next();
     if ($notnull_bool($eq(tok.kind, 6/*TokenKind.LBRACE*/))) {
       depth += 1;
     }
     else if ($notnull_bool($eq(tok.kind, 7/*TokenKind.RBRACE*/))) {
       depth -= 1;
       if (depth == 0) return;
     }
     else if ($notnull_bool($eq(tok.kind, 1/*TokenKind.END_OF_FILE*/))) {
       this._lang_error('unexpected end of file during diet parse', tok.get$span());
       return;
     }
   }
 }
-Parser.prototype._makeSpan = function(start) {
+lang_Parser.prototype._makeSpan = function(start) {
   return new SourceSpan(this.source, start, this._previousToken.end);
 }
-Parser.prototype.compilationUnit = function() {
+lang_Parser.prototype.compilationUnit = function() {
   var ret = [];
   this._maybeEat(13/*TokenKind.HASHBANG*/);
   while ($notnull_bool(this._peekKind(12/*TokenKind.HASH*/))) {
     ret.add$1(this.directive());
   }
   while (!$notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/))) {
     ret.add$1(this.topLevelDefinition());
   }
   return (ret && ret.is$List$Definition());
 }
-Parser.prototype.directive = function() {
+lang_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() {
+lang_Parser.prototype.topLevelDefinition = function() {
   switch (this._peek()) {
     case 73/*TokenKind.CLASS*/:
 
       return this.classDefinition(73/*TokenKind.CLASS*/);
 
     case 79/*TokenKind.INTERFACE*/:
 
       return this.classDefinition(79/*TokenKind.INTERFACE*/);
 
     case 87/*TokenKind.TYPEDEF*/:
 
       return this.functionTypeAlias();
 
     default:
 
       return this.declaration(true);
 
   }
 }
-Parser.prototype.classDefinition = function(kind) {
+lang_Parser.prototype.classDefinition = function(kind) {
   var start = this._peekToken.start;
   this._eat(kind);
   var name = this.identifier();
   var typeParams = null;
   if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     typeParams = this.typeParameters();
   }
   var _extends = null;
   if ($notnull_bool(this._maybeEat(74/*TokenKind.EXTENDS*/))) {
     _extends = this.typeList();
@@ skipping 15 matching lines @@
     while (!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/))) {
       if ($notnull_bool(this.isPrematureEndOfFile())) break;
       body.add$1(this.declaration(true));
     }
   }
   else {
     this._errorExpected('block starting with "{" or ";"');
   }
   return new TypeDefinition(kind == 73/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, _factory, body, this._makeSpan(start));
 }
-Parser.prototype.functionTypeAlias = function() {
+lang_Parser.prototype.functionTypeAlias = function() {
   var start = this._peekToken.start;
   this._eat(87/*TokenKind.TYPEDEF*/);
   var di = this.declaredIdentifier(false);
   var typeParams = null;
   if ($notnull_bool(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));
 }
-Parser.prototype.initializers = function() {
+lang_Parser.prototype.initializers = function() {
   this._inInitializers = true;
   var ret = [];
   do {
     ret.add$1(this.expression());
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   this._inInitializers = false;
   return ret;
 }
-Parser.prototype.functionBody = function(inExpression) {
+lang_Parser.prototype.functionBody = function(inExpression) {
   var start = this._peekToken.start;
   if ($notnull_bool(this._maybeEat(9/*TokenKind.ARROW*/))) {
     var expr = this.expression();
     if (!$notnull_bool(inExpression)) {
       this._eatSemicolon();
     }
     return new ReturnStatement(expr, this._makeSpan(start));
   }
   else if ($notnull_bool(this._peekKind(6/*TokenKind.LBRACE*/))) {
     if ($notnull_bool(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)');
 }
-Parser.prototype.finishField = function(start, modifiers, type, name, value) {
+lang_Parser.prototype.finishField = function(start, modifiers, type, name, value) {
   var names = [name];
   var values = [value];
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
     names.add$1(this.identifier());
     if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       values.add$1(this.expression());
     }
     else {
       values.add$1();
     }
   }
   this._eatSemicolon();
   return new VariableDefinition(modifiers, type, names, values, this._makeSpan($assert_num(start)));
 }
-Parser.prototype.finishDefinition = function(start, modifiers, di) {
+lang_Parser.prototype.finishDefinition = function(start, modifiers, di) {
   var $0;
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       var formals = this.formalParameterList();
       var inits = null;
       if ($notnull_bool(this._maybeEat(8/*TokenKind.COLON*/))) {
         inits = this.initializers();
       }
       var body = this.functionBody(false);
@@ skipping 13 matching lines @@
 
       return this.finishField(start, modifiers, di.type, di.get$name(), null);
 
     default:
 
       this._errorExpected('declaration');
       return null;
 
   }
 }
-Parser.prototype.declaration = function(includeOperators) {
+lang_Parser.prototype.declaration = function(includeOperators) {
   var start = this._peekToken.start;
   if ($notnull_bool(this._peekKind(75/*TokenKind.FACTORY*/))) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
   return this.finishDefinition(start, modifiers, this.declaredIdentifier(includeOperators));
 }
-Parser.prototype.factoryConstructorDeclaration = function() {
+lang_Parser.prototype.factoryConstructorDeclaration = function() {
   var start = this._peekToken.start;
   var factoryToken = this._lang_next();
   var names = [this.identifier()];
   while ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     names.add$1(this.identifier());
   }
   var typeParams = null;
   if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     typeParams = this.typeParameters();
   }
   var name = null;
   var type = null;
   if ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     name = this.identifier();
   }
   else if ($notnull_bool(typeParams == null)) {
     if (names.length > 1) {
       name = names.removeLast$0();
     }
     else {
-      name = new Identifier('', names.$index(0).get$span());
+      name = new lang_Identifier('', names.$index(0).get$span());
     }
   }
   else {
-    name = new Identifier('', names.$index(0).get$span());
+    name = new lang_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);
 }
-Parser.prototype.statement = function() {
+lang_Parser.prototype.statement = function() {
   var $0;
   switch (this._peek()) {
     case 88/*TokenKind.BREAK*/:
 
-      return (($0 = this.breakStatement()) && $0.is$Statement());
+      return (($0 = this.breakStatement()) && $0.is$lang_Statement());
 
     case 92/*TokenKind.CONTINUE*/:
 
-      return (($0 = this.continueStatement()) && $0.is$Statement());
+      return (($0 = this.continueStatement()) && $0.is$lang_Statement());
 
     case 105/*TokenKind.RETURN*/:
 
-      return (($0 = this.returnStatement()) && $0.is$Statement());
+      return (($0 = this.returnStatement()) && $0.is$lang_Statement());
 
     case 109/*TokenKind.THROW*/:
 
-      return (($0 = this.throwStatement()) && $0.is$Statement());
+      return (($0 = this.throwStatement()) && $0.is$lang_Statement());
 
     case 72/*TokenKind.ASSERT*/:
 
-      return (($0 = this.assertStatement()) && $0.is$Statement());
+      return (($0 = this.assertStatement()) && $0.is$lang_Statement());
 
     case 114/*TokenKind.WHILE*/:
 
       return this.whileStatement();
 
     case 94/*TokenKind.DO*/:
 
       return this.doStatement();
 
     case 99/*TokenKind.FOR*/:
 
-      return (($0 = this.forStatement()) && $0.is$Statement());
+      return (($0 = this.forStatement()) && $0.is$lang_Statement());
 
     case 100/*TokenKind.IF*/:
 
       return this.ifStatement();
 
     case 107/*TokenKind.SWITCH*/:
 
-      return (($0 = this.switchStatement()) && $0.is$Statement());
+      return (($0 = this.switchStatement()) && $0.is$lang_Statement());
 
     case 111/*TokenKind.TRY*/:
 
-      return (($0 = this.tryStatement()) && $0.is$Statement());
+      return (($0 = this.tryStatement()) && $0.is$lang_Statement());
 
     case 6/*TokenKind.LBRACE*/:
 
       return this.block();
 
     case 10/*TokenKind.SEMICOLON*/:
 
       return this.emptyStatement();
 
     case 97/*TokenKind.FINAL*/:
 
-      return (($0 = this.declaration(false)) && $0.is$Statement());
+      return (($0 = this.declaration(false)) && $0.is$lang_Statement());
 
     case 112/*TokenKind.VAR*/:
 
-      return (($0 = this.declaration(false)) && $0.is$Statement());
+      return (($0 = this.declaration(false)) && $0.is$lang_Statement());
 
     default:
 
-      return (($0 = this.finishExpressionAsStatement(this.expression())) && $0.is$Statement());
+      return (($0 = this.finishExpressionAsStatement(this.expression())) && $0.is$lang_Statement());
 
   }
 }
-Parser.prototype.finishExpressionAsStatement = function(expr) {
+lang_Parser.prototype.finishExpressionAsStatement = function(expr) {
   var $0;
   var start = expr.get$span().start;
   if ($notnull_bool(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 17 matching lines @@
     var gt = this._finishTypeArguments((baseType && baseType.is$TypeReference()), 0, typeArgs);
     var name = this.identifier();
     var value = null;
     if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       value = this.expression();
     }
     return this.finishField(expr.get$span().start, null, gt, name, value);
   }
   else {
     this._eatSemicolon();
-    return new ExpressionStatement(expr, this._makeSpan(expr.get$span().start));
+    return new lang_ExpressionStatement(expr, this._makeSpan(expr.get$span().start));
   }
 }
-Parser.prototype.testCondition = function() {
+lang_Parser.prototype.testCondition = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var ret = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
-  return (ret && ret.is$Expression());
+  return (ret && ret.is$lang_Expression());
 }
-Parser.prototype.block = function() {
+lang_Parser.prototype.block = function() {
   var start = this._peekToken.start;
   this._eat(6/*TokenKind.LBRACE*/);
   var stmts = [];
   while (!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     stmts.add$1(this.statement());
   }
   return new BlockStatement(stmts, this._makeSpan(start));
 }
-Parser.prototype.emptyStatement = function() {
+lang_Parser.prototype.emptyStatement = function() {
   var start = this._peekToken.start;
   this._eat(10/*TokenKind.SEMICOLON*/);
   return new EmptyStatement(this._makeSpan(start));
 }
-Parser.prototype.ifStatement = function() {
+lang_Parser.prototype.ifStatement = function() {
   var start = this._peekToken.start;
   this._eat(100/*TokenKind.IF*/);
   var test = this.testCondition();
   var trueBranch = this.statement();
   var falseBranch = null;
   if ($notnull_bool(this._maybeEat(95/*TokenKind.ELSE*/))) {
     falseBranch = this.statement();
   }
   return new IfStatement(test, trueBranch, falseBranch, this._makeSpan(start));
 }
-Parser.prototype.whileStatement = function() {
+lang_Parser.prototype.whileStatement = function() {
   var start = this._peekToken.start;
   this._eat(114/*TokenKind.WHILE*/);
   var test = this.testCondition();
   var body = this.statement();
   return new WhileStatement(test, body, this._makeSpan(start));
 }
-Parser.prototype.doStatement = function() {
+lang_Parser.prototype.doStatement = function() {
   var start = this._peekToken.start;
   this._eat(94/*TokenKind.DO*/);
   var body = this.statement();
   this._eat(114/*TokenKind.WHILE*/);
   var test = this.testCondition();
   this._eatSemicolon();
   return new DoStatement(body, test, this._makeSpan(start));
 }
-Parser.prototype.forStatement = function() {
+lang_Parser.prototype.forStatement = function() {
   var start = this._peekToken.start;
   this._eat(99/*TokenKind.FOR*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var init = this.forInitializerStatement(start);
   if ((init instanceof ForInStatement)) {
     return init;
   }
   var test = null;
   if (!$notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     test = this.expression();
     this._eatSemicolon();
   }
   var step = [];
   if (!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/))) {
     step.add$1(this.expression());
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       step.add$1(this.expression());
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   var body = this.statement();
   return new ForStatement(init, test, step, body, this._makeSpan(start));
 }
-Parser.prototype.forInitializerStatement = function(start) {
+lang_Parser.prototype.forInitializerStatement = function(start) {
   var $0;
   if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     return null;
   }
   else {
     var init = this.expression();
     if ($notnull_bool(this._peekKind(11/*TokenKind.COMMA*/)) && $notnull_bool(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 && baseType.is$TypeReference()), 0, typeArgs);
       var name = this.identifier();
       init = new DeclaredIdentifier(gt, name, this._makeSpan(init.get$span().start));
     }
     if ($notnull_bool(this._maybeEat(101/*TokenKind.IN*/))) {
       return this._finishForIn(start, (($0 = this._makeDeclaredIdentifier(init)) && $0.is$DeclaredIdentifier()));
     }
     else {
       return this.finishExpressionAsStatement(init);
     }
   }
 }
-Parser.prototype._finishForIn = function(start, di) {
+lang_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));
 }
-Parser.prototype.tryStatement = function() {
+lang_Parser.prototype.tryStatement = function() {
   var start = this._peekToken.start;
   this._eat(111/*TokenKind.TRY*/);
   var body = this.block();
   var catches = [];
   while ($notnull_bool(this._peekKind(90/*TokenKind.CATCH*/))) {
     catches.add$1(this.catchNode());
   }
   var finallyBlock = null;
   if ($notnull_bool(this._maybeEat(98/*TokenKind.FINALLY*/))) {
     finallyBlock = this.block();
   }
   return new TryStatement(body, catches, finallyBlock, this._makeSpan(start));
 }
-Parser.prototype.catchNode = function() {
+lang_Parser.prototype.catchNode = function() {
   var start = this._peekToken.start;
   this._eat(90/*TokenKind.CATCH*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var exc = this.declaredIdentifier(false);
   var trace = null;
   if ($notnull_bool(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() {
+lang_Parser.prototype.switchStatement = function() {
   var start = this._peekToken.start;
   this._eat(107/*TokenKind.SWITCH*/);
   var test = this.testCondition();
   var cases = [];
   this._eat(6/*TokenKind.LBRACE*/);
   while (!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/))) {
     cases.add$1(this.caseNode());
   }
   return new SwitchStatement(test, cases, this._makeSpan(start));
 }
-Parser.prototype._peekCaseEnd = function() {
+lang_Parser.prototype._peekCaseEnd = function() {
   var kind = this._peek();
   return $notnull_bool($eq(kind, 7/*TokenKind.RBRACE*/)) || $notnull_bool($eq(kind, 89/*TokenKind.CASE*/)) || $notnull_bool($eq(kind, 93/*TokenKind.DEFAULT*/));
 }
-Parser.prototype.caseNode = function() {
+lang_Parser.prototype.caseNode = function() {
   var start = this._peekToken.start;
   var label = null;
   if ($notnull_bool(this._peekIdentifier())) {
     label = this.identifier();
     this._eat(8/*TokenKind.COLON*/);
   }
   var cases = [];
   while (true) {
     if ($notnull_bool(this._maybeEat(89/*TokenKind.CASE*/))) {
       cases.add$1(this.expression());
@@ skipping 10 matching lines @@
   if (cases.length == 0) {
     this._lang_error('case or default');
   }
   var stmts = [];
   while (!$notnull_bool(this._peekCaseEnd())) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     stmts.add$1(this.statement());
   }
   return new CaseNode(label, cases, stmts, this._makeSpan(start));
 }
-Parser.prototype.returnStatement = function() {
+lang_Parser.prototype.returnStatement = function() {
   var start = this._peekToken.start;
   this._eat(105/*TokenKind.RETURN*/);
   var expr;
   if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     expr = null;
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ReturnStatement(expr, this._makeSpan(start));
 }
-Parser.prototype.throwStatement = function() {
+lang_Parser.prototype.throwStatement = function() {
   var start = this._peekToken.start;
   this._eat(109/*TokenKind.THROW*/);
   var expr;
   if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     expr = null;
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ThrowStatement(expr, this._makeSpan(start));
 }
-Parser.prototype.assertStatement = function() {
+lang_Parser.prototype.assertStatement = function() {
   var start = this._peekToken.start;
   this._eat(72/*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));
 }
-Parser.prototype.breakStatement = function() {
+lang_Parser.prototype.breakStatement = function() {
   var start = this._peekToken.start;
   this._eat(88/*TokenKind.BREAK*/);
   var name = null;
   if ($notnull_bool(this._peekIdentifier())) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new BreakStatement(name, this._makeSpan(start));
 }
-Parser.prototype.continueStatement = function() {
+lang_Parser.prototype.continueStatement = function() {
   var start = this._peekToken.start;
   this._eat(92/*TokenKind.CONTINUE*/);
   var name = null;
   if ($notnull_bool(this._peekIdentifier())) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new ContinueStatement(name, this._makeSpan(start));
 }
-Parser.prototype.expression = function() {
+lang_Parser.prototype.expression = function() {
   return this.infixExpression(0);
 }
-Parser.prototype._makeType = function(expr) {
+lang_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$1(expr.get$name());
     }
     type.span = expr.get$span();
     return type;
   }
   else {
     this._lang_error('expected type reference');
     return null;
   }
 }
-Parser.prototype.infixExpression = function(precedence) {
+lang_Parser.prototype.infixExpression = function(precedence) {
   var $0;
-  return this.finishInfixExpression((($0 = this.unaryExpression()) && $0.is$Expression()), precedence);
+  return this.finishInfixExpression((($0 = this.unaryExpression()) && $0.is$lang_Expression()), precedence);
 }
-Parser.prototype._finishDeclaredId = function(type) {
+lang_Parser.prototype._finishDeclaredId = function(type) {
   var name = this.identifier();
   return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan(type.get$span().start)));
 }
-Parser.prototype._fixAsType = function(x) {
+lang_Parser.prototype._fixAsType = function(x) {
   $assert(this._isBin(x, 52/*TokenKind.LT*/), "_isBin(x, TokenKind.LT)", "parser.dart", 790, 12);
   if ($notnull_bool(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 {
     $assert(this._peekKind(52/*TokenKind.LT*/), "_peekKind(TokenKind.LT)", "parser.dart", 801, 14);
     var base = this._makeType(x.x);
     var paramBase = this._makeType(x.y);
     var firstParam = this.addTypeArguments((paramBase && paramBase.is$TypeReference()), 1);
     var type;
     if (firstParam.depth <= 0) {
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     else if ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       type = this._finishTypeArguments((base && base.is$TypeReference()), 0, [firstParam]);
     }
     else {
       this._eat(53/*TokenKind.GT*/);
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     return this._finishDeclaredId(type);
   }
 }
-Parser.prototype.finishInfixExpression = function(x, precedence) {
+lang_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 ($notnull_bool(this._isBin(x, 52/*TokenKind.LT*/))) {
           return this._fixAsType((x && x.is$BinaryExpression()));
         }
       }
       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;
 }
-Parser.prototype._isPrefixUnaryOperator = function(kind) {
+lang_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;
 
     default:
 
       return false;
 
   }
 }
-Parser.prototype.unaryExpression = function() {
+lang_Parser.prototype.unaryExpression = function() {
   var start = this._peekToken.start;
   if ($notnull_bool(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());
 }
-Parser.prototype.argument = function() {
+lang_Parser.prototype.argument = function() {
   var start = this._peekToken.start;
   var expr;
   var label = null;
   if ($notnull_bool(this._maybeEat(15/*TokenKind.ELLIPSIS*/))) {
-    label = new Identifier('...', this._makeSpan(start));
+    label = new lang_Identifier('...', this._makeSpan(start));
   }
   expr = this.expression();
   if (label == null && $notnull_bool(this._maybeEat(8/*TokenKind.COLON*/))) {
     label = this._makeLabel(expr);
     expr = this.expression();
   }
   return new ArgumentNode(label, expr, this._makeSpan(start));
 }
-Parser.prototype.arguments = function() {
+lang_Parser.prototype.arguments = function() {
   var args = [];
   this._eat(2/*TokenKind.LPAREN*/);
   if (!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/))) {
     do {
       args.add$1(this.argument());
     }
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return args;
 }
-Parser.prototype.get$arguments = function() {
-  return Parser.prototype.arguments.bind(this);
+lang_Parser.prototype.get$arguments = function() {
+  return lang_Parser.prototype.arguments.bind(this);
 }
-Parser.prototype.finishPostfixExpression = function(expr) {
+lang_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)));
 
     case 4/*TokenKind.LBRACK*/:
 
       this._eat(4/*TokenKind.LBRACK*/);
       var index = this.expression();
       this._eat(5/*TokenKind.RBRACK*/);
@@ skipping 23 matching lines @@
 
       if ($notnull_bool(this._peekIdentifier())) {
         return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan(expr.get$span().start)));
       }
       else {
         return expr;
       }
 
   }
 }
-Parser.prototype._isBin = function(expr, kind) {
+lang_Parser.prototype._isBin = function(expr, kind) {
   return (expr instanceof BinaryExpression) && expr.op.kind == kind;
 }
-Parser.prototype._boolTypeRef = function(span) {
+lang_Parser.prototype._boolTypeRef = function(span) {
   return new TypeReference(span, world.nonNullBool);
 }
-Parser.prototype._intTypeRef = function(span) {
+lang_Parser.prototype._intTypeRef = function(span) {
   return new TypeReference(span, world.intType);
 }
-Parser.prototype._doubleTypeRef = function(span) {
+lang_Parser.prototype._doubleTypeRef = function(span) {
   return new TypeReference(span, world.doubleType);
 }
-Parser.prototype._stringTypeRef = function(span) {
+lang_Parser.prototype._stringTypeRef = function(span) {
   return new TypeReference(span, world.stringType);
 }
-Parser.prototype.primary = function() {
+lang_Parser.prototype.primary = function() {
   var start = this._peekToken.start;
   switch (this._peek()) {
     case 108/*TokenKind.THIS*/:
 
       this._eat(108/*TokenKind.THIS*/);
       return new ThisExpression(this._makeSpan(start));
 
     case 106/*TokenKind.SUPER*/:
 
       this._eat(106/*TokenKind.SUPER*/);
@@ skipping 44 matching lines @@
       return new LiteralExpression(true, this._boolTypeRef(this._makeSpan(start)), 'true', this._makeSpan(start));
 
     case 96/*TokenKind.FALSE*/:
 
       this._eat(96/*TokenKind.FALSE*/);
       return new LiteralExpression(false, this._boolTypeRef(this._makeSpan(start)), 'false', this._makeSpan(start));
 
     case 61/*TokenKind.HEX_INTEGER*/:
 
       var t = this._lang_next();
-      return new LiteralExpression(Parser.parseHex(t.get$text().substring(2)), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+      return new LiteralExpression(lang_Parser.parseHex(t.get$text().substring(2)), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 60/*TokenKind.INTEGER*/:
 
       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._lang_next();
       return new LiteralExpression(Math.parseDouble(t.get$text()), this._doubleTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
@@ skipping 18 matching lines @@
 
     default:
 
       if (!$notnull_bool(this._peekIdentifier())) {
         this._errorExpected('expression');
       }
       return new VarExpression(this.identifier(), this._makeSpan(start));
 
   }
 }
-Parser.prototype.stringInterpolation = function() {
+lang_Parser.prototype.stringInterpolation = function() {
   var start = this._peekToken.start;
   var lits = [];
   var startQuote = null, endQuote = null;
   while ($notnull_bool(this._peekKind(66/*TokenKind.INCOMPLETE_STRING*/))) {
     var token = this._lang_next();
     var text = token.get$text();
     if ($notnull_bool(startQuote == null)) {
       if ($notnull_bool(isMultilineString($assert_String(text)))) {
         endQuote = text.substring$2(0, 3);
         startQuote = $add(endQuote, '\n');
@@ skipping 21 matching lines @@
   }
   var tok = this._lang_next();
   if ($notnull_bool($ne(tok.kind, 58/*TokenKind.STRING*/))) {
     this._errorExpected('interpolated string');
   }
   var text = $add(startQuote, tok.get$text());
   lits.add$1(this.makeStringLiteral($assert_String(text), tok.get$span()));
   var span = this._makeSpan(start);
   return new LiteralExpression(lits, this._stringTypeRef((span && span.is$SourceSpan())), '\$\$\$', (span && span.is$SourceSpan()));
 }
-Parser.prototype.makeStringLiteral = function(text, span) {
+lang_Parser.prototype.makeStringLiteral = function(text, span) {
   return new LiteralExpression(text, this._stringTypeRef(span), text, span);
 }
-Parser.prototype.stringLiteralExpr = function() {
+lang_Parser.prototype.stringLiteralExpr = function() {
   var token = this._lang_next();
   return this.makeStringLiteral(token.get$text(), token.get$span());
 }
-Parser.prototype.maybeStringLiteral = function() {
+lang_Parser.prototype.maybeStringLiteral = function() {
   var kind = this._peek();
   if ($notnull_bool($eq(kind, 58/*TokenKind.STRING*/))) {
     return parseStringLiteral(this._lang_next().get$text());
   }
   else if ($notnull_bool($eq(kind, 59/*TokenKind.STRING_PART*/))) {
     this._lang_next();
     this._errorExpected('string literal, but found interpolated string start');
   }
   else if ($notnull_bool($eq(kind, 66/*TokenKind.INCOMPLETE_STRING*/))) {
     this._lang_next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
-Parser.prototype._parenOrLambda = function() {
+lang_Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
   var args = this.arguments();
   if (!$notnull_bool(this._inInitializers) && ($notnull_bool(this._peekKind(9/*TokenKind.ARROW*/)) || $notnull_bool(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();
     }
   }
 }
-Parser.prototype._typeAsIdentifier = function(type) {
+lang_Parser.prototype._typeAsIdentifier = function(type) {
   return type.get$name();
 }
-Parser.prototype._specialIdentifier = function(includeOperators) {
+lang_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.get$span());
       name = $assert_String(this.identifier().get$name());
       break;
 
@@ skipping 46 matching lines @@
           this._lang_next();
         }
       }
       break;
 
     default:
 
       return null;
 
   }
-  return new Identifier(name, this._makeSpan(start));
+  return new lang_Identifier(name, this._makeSpan(start));
 }
-Parser.prototype.declaredIdentifier = function(includeOperators) {
+lang_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 ($notnull_bool(this._peekIdentifier())) {
         name = this.identifier();
       }
       else if ((myType instanceof NameTypeReference) && $notnull_bool(myType.names == null)) {
         name = this._typeAsIdentifier(myType);
         myType = null;
       }
       else {
       }
     }
   }
   return new DeclaredIdentifier(myType, name, this._makeSpan(start));
 }
-Parser._hexDigit = function(c) {
+lang_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;
   }
 }
-Parser.parseHex = function(hex) {
+lang_Parser.parseHex = function(hex) {
   var result = 0;
   for (var i = 0;
    i < hex.length; i++) {
-    var digit = Parser._hexDigit(hex.charCodeAt(i));
+    var digit = lang_Parser._hexDigit(hex.charCodeAt(i));
     $assert($ne(digit, -1), "digit != -1", "parser.dart", 1261, 14);
     result = (result << 4) + $assert_num(digit);
   }
   return $assert_num(result);
 }
-Parser.prototype.finishNewExpression = function(start, isConst) {
+lang_Parser.prototype.finishNewExpression = function(start, isConst) {
   var type = this.type(0);
   var name = null;
   if ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     name = this.identifier();
   }
   var args = this.arguments();
-  return new NewExpression(isConst, type, name, args, this._makeSpan(start));
+  return new lang_NewExpression(isConst, type, name, args, this._makeSpan(start));
 }
-Parser.prototype.finishListLiteral = function(start, isConst, type) {
+lang_Parser.prototype.finishListLiteral = function(start, isConst, type) {
   if ($notnull_bool(this._maybeEat(56/*TokenKind.INDEX*/))) {
     return new ListExpression(isConst, type, [], this._makeSpan(start));
   }
   var values = [];
   this._eat(4/*TokenKind.LBRACK*/);
   while (!$notnull_bool(this._maybeEat(5/*TokenKind.RBRACK*/))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     values.add$1(this.expression());
     if (!$notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       this._eat(5/*TokenKind.RBRACK*/);
       break;
     }
   }
   return new ListExpression(isConst, type, values, this._makeSpan(start));
 }
-Parser.prototype.finishMapLiteral = function(start, isConst, type) {
+lang_Parser.prototype.finishMapLiteral = function(start, isConst, type) {
   var items = [];
   this._eat(6/*TokenKind.LBRACE*/);
   while (!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     items.add$1(this.expression());
     this._eat(8/*TokenKind.COLON*/);
     items.add$1(this.expression());
     if (!$notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       this._eat(7/*TokenKind.RBRACE*/);
       break;
     }
   }
   return new MapExpression(isConst, type, items, this._makeSpan(start));
 }
-Parser.prototype.finishTypedLiteral = function(start, isConst) {
+lang_Parser.prototype.finishTypedLiteral = function(start, isConst) {
   var span = this._makeSpan(start);
   var typeToBeNamedLater = new NameTypeReference(false, null, null, (span && span.is$SourceSpan()));
   var genericType = this.addTypeArguments((typeToBeNamedLater && typeToBeNamedLater.is$TypeReference()), 0);
   if ($notnull_bool(this._peekKind(4/*TokenKind.LBRACK*/)) || $notnull_bool(this._peekKind(56/*TokenKind.INDEX*/))) {
     return this.finishListLiteral(start, isConst, (genericType && genericType.is$TypeReference()));
   }
   else if ($notnull_bool(this._peekKind(6/*TokenKind.LBRACE*/))) {
     return this.finishMapLiteral(start, isConst, (genericType && genericType.is$TypeReference()));
   }
   else {
     this._errorExpected('array or map literal');
   }
 }
-Parser.prototype._readModifiers = function() {
+lang_Parser.prototype._readModifiers = function() {
   var modifiers = null;
   while (true) {
     switch (this._peek()) {
       case 86/*TokenKind.STATIC*/:
       case 97/*TokenKind.FINAL*/:
       case 91/*TokenKind.CONST*/:
       case 71/*TokenKind.ABSTRACT*/:
       case 75/*TokenKind.FACTORY*/:
 
         if (modifiers == null) modifiers = [];
         modifiers.add$1(this._lang_next());
         break;
 
       default:
 
         return modifiers;
 
     }
   }
   return null;
 }
-Parser.prototype.typeParameter = function() {
+lang_Parser.prototype.typeParameter = function() {
   var start = this._peekToken.start;
   var name = this.identifier();
   var myType = null;
   if ($notnull_bool(this._maybeEat(74/*TokenKind.EXTENDS*/))) {
     myType = this.type(1);
   }
   return new TypeParameter(name, myType, this._makeSpan(start));
 }
-Parser.prototype.typeParameters = function() {
+lang_Parser.prototype.typeParameters = function() {
   this._eat(52/*TokenKind.LT*/);
   var closed = false;
   var ret = [];
   do {
     var tp = this.typeParameter();
     ret.add$1(tp);
     if ((tp.extendsType instanceof GenericTypeReference) && tp.extendsType.depth == 0) {
       closed = true;
       break;
     }
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   if (!$notnull_bool(closed)) {
     this._eat(53/*TokenKind.GT*/);
   }
   return ret;
 }
-Parser.prototype.get$typeParameters = function() {
-  return Parser.prototype.typeParameters.bind(this);
+lang_Parser.prototype.get$typeParameters = function() {
+  return lang_Parser.prototype.typeParameters.bind(this);
 }
-Parser.prototype._eatClosingAngle = function(depth) {
+lang_Parser.prototype._eatClosingAngle = function(depth) {
   if ($notnull_bool(this._maybeEat(53/*TokenKind.GT*/))) {
     return depth;
   }
   else if (depth > 0 && $notnull_bool(this._maybeEat(40/*TokenKind.SAR*/))) {
     return depth - 1;
   }
   else if (depth > 1 && $notnull_bool(this._maybeEat(41/*TokenKind.SHR*/))) {
     return depth - 2;
   }
   else {
     this._errorExpected('>');
     return depth;
   }
 }
-Parser.prototype.addTypeArguments = function(baseType, depth) {
+lang_Parser.prototype.addTypeArguments = function(baseType, depth) {
   this._eat(52/*TokenKind.LT*/);
   return this._finishTypeArguments(baseType, depth, []);
 }
-Parser.prototype._finishTypeArguments = function(baseType, depth, types) {
+lang_Parser.prototype._finishTypeArguments = function(baseType, depth, types) {
   var delta = -1;
   do {
     var myType = this.type(depth + 1);
     types.add$1(myType);
     if ((myType instanceof GenericTypeReference) && myType.depth <= depth) {
       delta = depth - myType.depth;
       break;
     }
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   if (delta >= 0) {
     depth -= $assert_num(delta);
   }
   else {
     depth = this._eatClosingAngle(depth);
   }
   var span = this._makeSpan(baseType.span.start);
   return new GenericTypeReference(baseType, types, depth, (span && span.is$SourceSpan()));
 }
-Parser.prototype.typeList = function() {
+lang_Parser.prototype.typeList = function() {
   var types = [];
   do {
     types.add$1(this.type(0));
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   return types;
 }
-Parser.prototype.type = function(depth) {
+lang_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 113/*TokenKind.VOID*/:
 
       return new TypeReference(this._lang_next().get$span(), world.voidType);
 
@@ skipping 19 matching lines @@
     names.add$1(this.identifier());
   }
   var typeRef = new NameTypeReference(isFinal, name, names, this._makeSpan(start));
   if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     return this.addTypeArguments((typeRef && typeRef.is$TypeReference()), depth);
   }
   else {
     return typeRef;
   }
 }
-Parser.prototype.get$type = function() {
-  return Parser.prototype.type.bind(this);
+lang_Parser.prototype.get$type = function() {
+  return lang_Parser.prototype.type.bind(this);
 }
-Parser.prototype.formalParameter = function(inOptionalBlock) {
+lang_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 ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
     if (!$notnull_bool(inOptionalBlock)) {
       this._lang_error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
   else if ($notnull_bool(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 ($notnull_bool(inOptionalBlock) && $notnull_bool(value == null)) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
 }
-Parser.prototype.formalParameterList = function() {
+lang_Parser.prototype.formalParameterList = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var formals = [];
   var inOptionalBlock = false;
   if (!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/))) {
     if ($notnull_bool(this._maybeEat(4/*TokenKind.LBRACK*/))) {
       inOptionalBlock = true;
     }
     formals.add$1(this.formalParameter($assert_bool(inOptionalBlock)));
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       if ($notnull_bool(this._maybeEat(4/*TokenKind.LBRACK*/))) {
         if ($notnull_bool(inOptionalBlock)) {
           this._lang_error('already inside an optional block', this._previousToken.get$span());
         }
         inOptionalBlock = true;
       }
       formals.add$1(this.formalParameter($assert_bool(inOptionalBlock)));
     }
     if ($notnull_bool(inOptionalBlock)) {
       this._eat(5/*TokenKind.RBRACK*/);
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return formals;
 }
-Parser.prototype.identifier = function() {
+lang_Parser.prototype.identifier = function() {
   var tok = this._lang_next();
   if (!$notnull_bool(TokenKind.isIdentifier($assert_num(tok.kind)))) {
     this._lang_error(('expected identifier, but found ' + tok + ''), tok.get$span());
   }
-  return new Identifier(tok.get$text(), this._makeSpan(tok.start));
+  return new lang_Identifier(tok.get$text(), this._makeSpan(tok.start));
 }
-Parser.prototype._makeFunction = function(expr, body) {
+lang_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 && span.is$SourceSpan()));
     return new LambdaExpression(func, func.get$span());
   }
   else {
     this._lang_error('expected function');
   }
 }
-Parser.prototype._makeFormal = function(expr) {
+lang_Parser.prototype._makeFormal = function(expr) {
   var $0;
   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 ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/)) && ((expr.x instanceof DeclaredIdentifier))) {
     var di = (($0 = expr.x) && $0.is$DeclaredIdentifier());
     return new FormalNode(false, false, di.type, di.name, expr.y, expr.get$span());
   }
   else if ($notnull_bool(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());
   }
 }
-Parser.prototype._makeFormalsFromList = function(expr) {
+lang_Parser.prototype._makeFormalsFromList = function(expr) {
   if ($notnull_bool(expr.get$isConst())) {
     this._lang_error('expected formal, but found "const"', expr.get$span());
   }
   else if ($notnull_bool($ne(expr.type, null))) {
     this._lang_error('expected formal, but found generic type arguments', expr.type.get$span());
   }
   return this._makeFormalsFromExpressions(expr.values, false);
 }
-Parser.prototype._makeFormals = function(arguments) {
+lang_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$1(arg.get$value());
   }
   return this._makeFormalsFromExpressions(expressions, true);
 }
-Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
+lang_Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
   var $0;
   var formals = [];
   for (var i = 0;
    i < expressions.length; i++) {
     var formal = this._makeFormal(expressions.$index(i));
     if ($notnull_bool(formal == null)) {
       var baseType = this._makeType(expressions.$index(i).x);
       var typeParams = [this._makeType(expressions.$index(i).y)];
       i++;
       while (i < expressions.length) {
@@ skipping 23 matching lines @@
       if (!$notnull_bool(allowOptional)) {
         this._lang_error('unexpected nested optional formal', expressions.$index(i).get$span());
       }
     }
     else {
       formals.add$1(formal);
     }
   }
   return formals;
 }
-Parser.prototype._makeDeclaredIdentifier = function(e) {
+lang_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());
   }
 }
-Parser.prototype._makeLabel = function(expr) {
+lang_Parser.prototype._makeLabel = function(expr) {
   if ((expr instanceof VarExpression)) {
     return expr.get$name();
   }
   else {
     this._errorExpected('label');
     return null;
   }
 }
-Parser.prototype.block$0 = function() {
+lang_Parser.prototype.block$0 = function() {
   return this.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 $assert_String(this.token.get$span().toMessageString(('Unexpected ' + this.token + '')));
 }
 IncompleteSourceException.prototype.toString$0 = function() {
   return this.toString();
 };
-// ********** Code for Node **************
-function Node(span) {
+// ********** Code for lang_Node **************
+function lang_Node(span) {
   this.span = span;
   // Initializers done
 }
-Node.prototype.is$Node = function(){return this;};
-Node.prototype.get$span = function() { return this.span; };
-Node.prototype.set$span = function(value) { return this.span = value; };
-Node.prototype.visit$1 = function($0) {
+lang_Node.prototype.is$lang_Node = function(){return this;};
+lang_Node.prototype.get$span = function() { return this.span; };
+lang_Node.prototype.set$span = function(value) { return this.span = value; };
+lang_Node.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for Definition **************
 function Definition(span) {
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(Definition, Statement);
+$inherits(Definition, lang_Statement);
 Definition.prototype.is$Definition = function(){return this;};
 Definition.prototype.get$typeParameters = function() {
   return null;
 }
 Definition.prototype.get$nativeType = function() {
   return null;
 }
-// ********** Code for Statement **************
-function Statement(span) {
+// ********** Code for lang_Statement **************
+function lang_Statement(span) {
   // Initializers done
-  Node.call(this, span);
+  lang_Node.call(this, span);
 }
-$inherits(Statement, Node);
-Statement.prototype.is$Statement = function(){return this;};
-// ********** Code for Expression **************
-function Expression(span) {
+$inherits(lang_Statement, lang_Node);
+lang_Statement.prototype.is$lang_Statement = function(){return this;};
+// ********** Code for lang_Expression **************
+function lang_Expression(span) {
   // Initializers done
-  Node.call(this, span);
+  lang_Node.call(this, span);
 }
-$inherits(Expression, Node);
-Expression.prototype.is$Expression = function(){return this;};
+$inherits(lang_Expression, lang_Node);
+lang_Expression.prototype.is$lang_Expression = function(){return this;};
 // ********** Code for TypeReference **************
 function TypeReference(span, type) {
   this.type = type;
   // Initializers done
-  Node.call(this, span);
+  lang_Node.call(this, span);
 }
-$inherits(TypeReference, Node);
+$inherits(TypeReference, lang_Node);
 TypeReference.prototype.is$TypeReference = function(){return this;};
 TypeReference.prototype.get$type = function() { return this.type; };
 TypeReference.prototype.set$type = function(value) { return this.type = value; };
 TypeReference.prototype.visit = function(visitor) {
   return visitor.visitTypeReference(this);
 }
 TypeReference.prototype.get$isFinal = function() {
   return false;
 }
 TypeReference.prototype.visit$1 = function($0) {
@@ skipping 100 matching lines @@
 FunctionDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
 }
 FunctionDefinition.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ReturnStatement **************
 function ReturnStatement(value, span) {
   this.value = value;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(ReturnStatement, Statement);
+$inherits(ReturnStatement, lang_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);
 }
 ReturnStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ThrowStatement **************
 function ThrowStatement(value, span) {
   this.value = value;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(ThrowStatement, Statement);
+$inherits(ThrowStatement, lang_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);
 }
 ThrowStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for AssertStatement **************
 function AssertStatement(test, span) {
   this.test = test;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(AssertStatement, Statement);
+$inherits(AssertStatement, lang_Statement);
 AssertStatement.prototype.visit = function(visitor) {
   return visitor.visitAssertStatement(this);
 }
 AssertStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for BreakStatement **************
 function BreakStatement(label, span) {
   this.label = label;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(BreakStatement, Statement);
+$inherits(BreakStatement, lang_Statement);
 BreakStatement.prototype.visit = function(visitor) {
   return visitor.visitBreakStatement(this);
 }
 BreakStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ContinueStatement **************
 function ContinueStatement(label, span) {
   this.label = label;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(ContinueStatement, Statement);
+$inherits(ContinueStatement, lang_Statement);
 ContinueStatement.prototype.visit = function(visitor) {
   return visitor.visitContinueStatement(this);
 }
 ContinueStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for IfStatement **************
 function IfStatement(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(IfStatement, Statement);
+$inherits(IfStatement, lang_Statement);
 IfStatement.prototype.visit = function(visitor) {
   return visitor.visitIfStatement(this);
 }
 IfStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for WhileStatement **************
 function WhileStatement(test, body, span) {
   this.test = test;
   this.body = body;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(WhileStatement, Statement);
+$inherits(WhileStatement, lang_Statement);
 WhileStatement.prototype.visit = function(visitor) {
   return visitor.visitWhileStatement(this);
 }
 WhileStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for DoStatement **************
 function DoStatement(body, test, span) {
   this.body = body;
   this.test = test;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(DoStatement, Statement);
+$inherits(DoStatement, lang_Statement);
 DoStatement.prototype.visit = function(visitor) {
   return visitor.visitDoStatement(this);
 }
 DoStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ForStatement **************
 function ForStatement(init, test, step, body, span) {
   this.init = init;
   this.test = test;
   this.step = step;
   this.body = body;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(ForStatement, Statement);
+$inherits(ForStatement, lang_Statement);
 ForStatement.prototype.visit = function(visitor) {
   return visitor.visitForStatement(this);
 }
 ForStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ForInStatement **************
 function ForInStatement(item, list, body, span) {
   this.item = item;
   this.list = list;
   this.body = body;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(ForInStatement, Statement);
+$inherits(ForInStatement, lang_Statement);
 ForInStatement.prototype.visit = function(visitor) {
   return visitor.visitForInStatement(this);
 }
 ForInStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for TryStatement **************
 function TryStatement(body, catches, finallyBlock, span) {
   this.body = body;
   this.catches = catches;
   this.finallyBlock = finallyBlock;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(TryStatement, Statement);
+$inherits(TryStatement, lang_Statement);
 TryStatement.prototype.visit = function(visitor) {
   return visitor.visitTryStatement(this);
 }
 TryStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for SwitchStatement **************
 function SwitchStatement(test, cases, span) {
   this.test = test;
   this.cases = cases;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(SwitchStatement, Statement);
+$inherits(SwitchStatement, lang_Statement);
 SwitchStatement.prototype.visit = function(visitor) {
   return visitor.visitSwitchStatement(this);
 }
 SwitchStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for BlockStatement **************
 function BlockStatement(body, span) {
   this.body = body;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(BlockStatement, Statement);
+$inherits(BlockStatement, lang_Statement);
 BlockStatement.prototype.is$BlockStatement = function(){return this;};
 BlockStatement.prototype.visit = function(visitor) {
   return visitor.visitBlockStatement(this);
 }
 BlockStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for LabeledStatement **************
 function LabeledStatement(name, body, span) {
   this.name = name;
   this.body = body;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(LabeledStatement, Statement);
+$inherits(LabeledStatement, lang_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);
 }
 LabeledStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
-// ********** Code for ExpressionStatement **************
-function ExpressionStatement(body, span) {
+// ********** Code for lang_ExpressionStatement **************
+function lang_ExpressionStatement(body, span) {
   this.body = body;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(ExpressionStatement, Statement);
-ExpressionStatement.prototype.visit = function(visitor) {
+$inherits(lang_ExpressionStatement, lang_Statement);
+lang_ExpressionStatement.prototype.visit = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
-ExpressionStatement.prototype.visit$1 = function($0) {
+lang_ExpressionStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for EmptyStatement **************
 function EmptyStatement(span) {
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(EmptyStatement, Statement);
+$inherits(EmptyStatement, lang_Statement);
 EmptyStatement.prototype.visit = function(visitor) {
   return visitor.visitEmptyStatement(this);
 }
 EmptyStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for DietStatement **************
 function DietStatement(span) {
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(DietStatement, Statement);
+$inherits(DietStatement, lang_Statement);
 DietStatement.prototype.visit = function(visitor) {
   return visitor.visitDietStatement(this);
 }
 DietStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for NativeStatement **************
 function NativeStatement(body, span) {
   this.body = body;
   // Initializers done
-  Statement.call(this, span);
+  lang_Statement.call(this, span);
 }
-$inherits(NativeStatement, Statement);
+$inherits(NativeStatement, lang_Statement);
 NativeStatement.prototype.visit = function(visitor) {
   return visitor.visitNativeStatement(this);
 }
 NativeStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for LambdaExpression **************
 function LambdaExpression(func, span) {
   this.func = func;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(LambdaExpression, Expression);
+$inherits(LambdaExpression, lang_Expression);
 LambdaExpression.prototype.is$LambdaExpression = function(){return this;};
 LambdaExpression.prototype.visit = function(visitor) {
   return visitor.visitLambdaExpression(this);
 }
 LambdaExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for CallExpression **************
 function CallExpression(target, arguments, span) {
   this.target = target;
   this.arguments = arguments;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(CallExpression, Expression);
+$inherits(CallExpression, lang_Expression);
 CallExpression.prototype.is$CallExpression = function(){return this;};
 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);
 }
 CallExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for IndexExpression **************
 function IndexExpression(target, index, span) {
   this.target = target;
   this.index = index;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(IndexExpression, Expression);
+$inherits(IndexExpression, lang_Expression);
 IndexExpression.prototype.is$IndexExpression = function(){return this;};
 IndexExpression.prototype.visit = function(visitor) {
   return visitor.visitIndexExpression(this);
 }
 IndexExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for BinaryExpression **************
 function BinaryExpression(op, x, y, span) {
   this.op = op;
   this.x = x;
   this.y = y;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(BinaryExpression, Expression);
+$inherits(BinaryExpression, lang_Expression);
 BinaryExpression.prototype.is$BinaryExpression = function(){return this;};
 BinaryExpression.prototype.visit = function(visitor) {
   return visitor.visitBinaryExpression(this);
 }
 BinaryExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for UnaryExpression **************
 function UnaryExpression(op, self, span) {
   this.op = op;
   this.self = self;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(UnaryExpression, Expression);
+$inherits(UnaryExpression, lang_Expression);
 UnaryExpression.prototype.visit = function(visitor) {
   return visitor.visitUnaryExpression(this);
 }
 UnaryExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for PostfixExpression **************
 function PostfixExpression(body, op, span) {
   this.body = body;
   this.op = op;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(PostfixExpression, Expression);
+$inherits(PostfixExpression, lang_Expression);
 PostfixExpression.prototype.is$PostfixExpression = function(){return this;};
 PostfixExpression.prototype.visit = function(visitor) {
   return visitor.visitPostfixExpression$1(this);
 }
 PostfixExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
-// ********** Code for NewExpression **************
-function NewExpression(isConst, type, name, arguments, span) {
+// ********** Code for lang_NewExpression **************
+function lang_NewExpression(isConst, type, name, arguments, span) {
   this.isConst = isConst;
   this.type = type;
   this.name = name;
   this.arguments = arguments;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(NewExpression, Expression);
-NewExpression.prototype.get$isConst = function() { return this.isConst; };
-NewExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
-NewExpression.prototype.get$type = function() { return this.type; };
-NewExpression.prototype.set$type = function(value) { return this.type = 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) {
+$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$type = function() { return this.type; };
+lang_NewExpression.prototype.set$type = function(value) { return this.type = 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) {
   return visitor.visitNewExpression(this);
 }
-NewExpression.prototype.visit$1 = function($0) {
+lang_NewExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ListExpression **************
 function ListExpression(isConst, type, values, span) {
   this.isConst = isConst;
   this.type = type;
   this.values = values;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(ListExpression, Expression);
+$inherits(ListExpression, lang_Expression);
 ListExpression.prototype.get$isConst = function() { return this.isConst; };
 ListExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 ListExpression.prototype.get$type = function() { return this.type; };
 ListExpression.prototype.set$type = function(value) { return this.type = value; };
 ListExpression.prototype.visit = function(visitor) {
   return visitor.visitListExpression(this);
 }
 ListExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for MapExpression **************
 function MapExpression(isConst, type, items, span) {
   this.isConst = isConst;
   this.type = type;
   this.items = items;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(MapExpression, Expression);
+$inherits(MapExpression, lang_Expression);
 MapExpression.prototype.get$isConst = function() { return this.isConst; };
 MapExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 MapExpression.prototype.get$type = function() { return this.type; };
 MapExpression.prototype.set$type = function(value) { return this.type = value; };
 MapExpression.prototype.visit = function(visitor) {
   return visitor.visitMapExpression(this);
 }
 MapExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ConditionalExpression **************
 function ConditionalExpression(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(ConditionalExpression, Expression);
+$inherits(ConditionalExpression, lang_Expression);
 ConditionalExpression.prototype.visit = function(visitor) {
   return visitor.visitConditionalExpression(this);
 }
 ConditionalExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for IsExpression **************
 function IsExpression(isTrue, x, type, span) {
   this.isTrue = isTrue;
   this.x = x;
   this.type = type;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(IsExpression, Expression);
+$inherits(IsExpression, lang_Expression);
 IsExpression.prototype.get$type = function() { return this.type; };
 IsExpression.prototype.set$type = function(value) { return this.type = value; };
 IsExpression.prototype.visit = function(visitor) {
   return visitor.visitIsExpression(this);
 }
 IsExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ParenExpression **************
 function ParenExpression(body, span) {
   this.body = body;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(ParenExpression, Expression);
+$inherits(ParenExpression, lang_Expression);
 ParenExpression.prototype.visit = function(visitor) {
   return visitor.visitParenExpression(this);
 }
 ParenExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for DotExpression **************
 function DotExpression(self, name, span) {
   this.self = self;
   this.name = name;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(DotExpression, Expression);
+$inherits(DotExpression, lang_Expression);
 DotExpression.prototype.is$DotExpression = function(){return this;};
 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);
 }
 DotExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for VarExpression **************
 function VarExpression(name, span) {
   this.name = name;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(VarExpression, Expression);
+$inherits(VarExpression, lang_Expression);
 VarExpression.prototype.is$VarExpression = function(){return this;};
 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);
 }
 VarExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ThisExpression **************
 function ThisExpression(span) {
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(ThisExpression, Expression);
+$inherits(ThisExpression, lang_Expression);
 ThisExpression.prototype.visit = function(visitor) {
   return visitor.visitThisExpression(this);
 }
 ThisExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for SuperExpression **************
 function SuperExpression(span) {
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(SuperExpression, Expression);
+$inherits(SuperExpression, lang_Expression);
 SuperExpression.prototype.visit = function(visitor) {
   return visitor.visitSuperExpression(this);
 }
 SuperExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for NullExpression **************
 function NullExpression(span) {
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(NullExpression, Expression);
+$inherits(NullExpression, lang_Expression);
 NullExpression.prototype.visit = function(visitor) {
   return visitor.visitNullExpression(this);
 }
 NullExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for LiteralExpression **************
 function LiteralExpression(value, type, text, span) {
   this.value = value;
   this.type = type;
   this.text = text;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(LiteralExpression, Expression);
+$inherits(LiteralExpression, lang_Expression);
 LiteralExpression.prototype.get$value = function() { return this.value; };
 LiteralExpression.prototype.set$value = function(value) { return this.value = value; };
 LiteralExpression.prototype.get$type = function() { return this.type; };
 LiteralExpression.prototype.set$type = function(value) { return this.type = 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);
 }
 LiteralExpression.prototype.visit$1 = function($0) {
@@ skipping 50 matching lines @@
   return visitor.visitFunctionTypeReference(this);
 }
 FunctionTypeReference.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ArgumentNode **************
 function ArgumentNode(label, value, span) {
   this.label = label;
   this.value = value;
   // Initializers done
-  Node.call(this, span);
+  lang_Node.call(this, span);
 }
-$inherits(ArgumentNode, Node);
+$inherits(ArgumentNode, lang_Node);
 ArgumentNode.prototype.is$ArgumentNode = function(){return this;};
 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);
 }
 ArgumentNode.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** 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;
   // Initializers done
-  Node.call(this, span);
+  lang_Node.call(this, span);
 }
-$inherits(FormalNode, Node);
+$inherits(FormalNode, lang_Node);
 FormalNode.prototype.get$type = function() { return this.type; };
 FormalNode.prototype.set$type = function(value) { return this.type = value; };
 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);
 }
 FormalNode.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for CatchNode **************
 function CatchNode(exception, trace, body, span) {
   this.exception = exception;
   this.trace = trace;
   this.body = body;
   // Initializers done
-  Node.call(this, span);
+  lang_Node.call(this, span);
 }
-$inherits(CatchNode, Node);
+$inherits(CatchNode, lang_Node);
 CatchNode.prototype.get$exception = function() { return this.exception; };
 CatchNode.prototype.set$exception = function(value) { return this.exception = value; };
 CatchNode.prototype.visit = function(visitor) {
   return visitor.visitCatchNode(this);
 }
 CatchNode.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for CaseNode **************
 function CaseNode(label, cases, statements, span) {
   this.label = label;
   this.cases = cases;
   this.statements = statements;
   // Initializers done
-  Node.call(this, span);
+  lang_Node.call(this, span);
 }
-$inherits(CaseNode, Node);
+$inherits(CaseNode, lang_Node);
 CaseNode.prototype.visit = function(visitor) {
   return visitor.visitCaseNode(this);
 }
 CaseNode.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for TypeParameter **************
 function TypeParameter(name, extendsType, span) {
   this.name = name;
   this.extendsType = extendsType;
   // Initializers done
-  Node.call(this, span);
+  lang_Node.call(this, span);
 }
-$inherits(TypeParameter, Node);
+$inherits(TypeParameter, lang_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);
 }
 TypeParameter.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
-// ********** Code for Identifier **************
-function Identifier(name, span) {
+// ********** Code for lang_Identifier **************
+function lang_Identifier(name, span) {
   this.name = name;
   // Initializers done
-  Node.call(this, span);
+  lang_Node.call(this, span);
 }
-$inherits(Identifier, Node);
-Identifier.prototype.is$Identifier = function(){return this;};
-Identifier.prototype.get$name = function() { return this.name; };
-Identifier.prototype.set$name = function(value) { return this.name = value; };
-Identifier.prototype.visit = function(visitor) {
+$inherits(lang_Identifier, lang_Node);
+lang_Identifier.prototype.is$lang_Identifier = function(){return this;};
+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) {
   return visitor.visitIdentifier(this);
 }
-Identifier.prototype.visit$1 = function($0) {
+lang_Identifier.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for DeclaredIdentifier **************
 function DeclaredIdentifier(type, name, span) {
   this.type = type;
   this.name = name;
   // Initializers done
-  Expression.call(this, span);
+  lang_Expression.call(this, span);
 }
-$inherits(DeclaredIdentifier, Expression);
+$inherits(DeclaredIdentifier, lang_Expression);
 DeclaredIdentifier.prototype.is$DeclaredIdentifier = function(){return this;};
 DeclaredIdentifier.prototype.get$type = function() { return this.type; };
 DeclaredIdentifier.prototype.set$type = function(value) { return this.type = value; };
 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);
 }
 DeclaredIdentifier.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
-// ********** Code for Type **************
-function Type(name) {
+// ********** Code for lang_Type **************
+function lang_Type(name) {
   this.name = name;
   this.isTested = false;
   // Initializers done
 }
-Type.prototype.is$Type = function(){return this;};
-Type.prototype.is$Named = function(){return this;};
-Type.prototype.get$name = function() { return this.name; };
-Type.prototype.markUsed = function() {
+lang_Type.prototype.is$lang_Type = function(){return this;};
+lang_Type.prototype.is$Named = function(){return this;};
+lang_Type.prototype.get$name = function() { return this.name; };
+lang_Type.prototype.markUsed = function() {
 
 }
-Type.prototype.get$typeMember = function() {
+lang_Type.prototype.get$typeMember = function() {
   var $0;
   if (this._typeMember == null) {
     this._typeMember = new TypeMember((this && this.is$DefinedType()));
   }
   return (($0 = this._typeMember) && $0.is$TypeMember());
 }
-Type.prototype.getMember = function(name) {
+lang_Type.prototype.getMember = function(name) {
   return null;
 }
-Type.prototype.get$isVar = function() {
+lang_Type.prototype.get$isVar = function() {
   return false;
 }
-Type.prototype.get$isTop = function() {
+lang_Type.prototype.get$isTop = function() {
   return false;
 }
-Type.prototype.get$isObject = function() {
+lang_Type.prototype.get$isObject = function() {
   return false;
 }
-Type.prototype.get$isString = function() {
+lang_Type.prototype.get$isString = function() {
   return false;
 }
-Type.prototype.get$isBool = function() {
+lang_Type.prototype.get$isBool = function() {
   return false;
 }
-Type.prototype.get$isFunction = function() {
+lang_Type.prototype.get$isFunction = function() {
   return false;
 }
-Type.prototype.get$isList = function() {
+lang_Type.prototype.get$isList = function() {
   return false;
 }
-Type.prototype.get$isNum = function() {
+lang_Type.prototype.get$isNum = function() {
   return false;
 }
-Type.prototype.get$isVoid = function() {
+lang_Type.prototype.get$isVoid = function() {
   return false;
 }
-Type.prototype.get$isNullable = function() {
+lang_Type.prototype.get$isNullable = function() {
   return true;
 }
-Type.prototype.get$isVarOrFunction = function() {
+lang_Type.prototype.get$isVarOrFunction = function() {
   return $notnull_bool(this.get$isVar()) || $notnull_bool(this.get$isFunction());
 }
-Type.prototype.get$isVarOrObject = function() {
+lang_Type.prototype.get$isVarOrObject = function() {
   return $notnull_bool(this.get$isVar()) || $notnull_bool(this.get$isObject());
 }
-Type.prototype.getCallMethod = function() {
+lang_Type.prototype.getCallMethod = function() {
   return null;
 }
-Type.prototype.get$isClosed = function() {
+lang_Type.prototype.get$isClosed = function() {
   return $notnull_bool(this.get$isString()) || $notnull_bool(this.get$isBool()) || $notnull_bool(this.get$isNum()) || $notnull_bool(this.get$isFunction()) || $notnull_bool(this.get$isVar());
 }
-Type.prototype.get$isUsed = function() {
+lang_Type.prototype.get$isUsed = function() {
   return false;
 }
-Type.prototype.get$isGeneric = function() {
+lang_Type.prototype.get$isGeneric = function() {
   return false;
 }
-Type.prototype.get$isNativeType = function() {
+lang_Type.prototype.get$isNativeType = function() {
   return false;
 }
-Type.prototype.get$isNative = function() {
+lang_Type.prototype.get$isNative = function() {
   return this.get$isNativeType();
 }
-Type.prototype.get$hasTypeParams = function() {
+lang_Type.prototype.get$hasTypeParams = function() {
   return false;
 }
-Type.prototype.get$typeofName = function() {
+lang_Type.prototype.get$typeofName = function() {
   return null;
 }
-Type.prototype.get$jsname = function() {
+lang_Type.prototype.get$jsname = function() {
   return this._jsname == null ? this.name : this._jsname;
 }
-Type.prototype.set$jsname = function(name) {
+lang_Type.prototype.set$jsname = function(name) {
   return this._jsname = name;
 }
-Type.prototype.get$members = function() {
+lang_Type.prototype.get$members = function() {
   return null;
 }
-Type.prototype.get$definition = function() {
+lang_Type.prototype.get$definition = function() {
   return null;
 }
-Type.prototype.get$factories = function() {
+lang_Type.prototype.get$factories = function() {
   return null;
 }
-Type.prototype.get$typeArgsInOrder = function() {
+lang_Type.prototype.get$typeArgsInOrder = function() {
   return null;
 }
-Type.prototype.get$genericType = function() {
+lang_Type.prototype.get$genericType = function() {
   return (this && this.is$DefinedType());
 }
-Type.prototype.get$interfaces = function() {
+lang_Type.prototype.get$interfaces = function() {
   return null;
 }
-Type.prototype.get$parent = function() {
+lang_Type.prototype.get$parent = function() {
   return null;
 }
-Type.prototype.getAllMembers = function() {
+lang_Type.prototype.getAllMembers = function() {
   return $map([]);
 }
-Type.prototype.hashCode = function() {
+lang_Type.prototype.hashCode = function() {
   return this.name.hashCode();
 }
-Type.prototype.ensureSubtypeOf = function(other, span, typeErrors) {
+lang_Type.prototype.ensureSubtypeOf = function(other, span, typeErrors) {
   if (!$notnull_bool(this.isSubtypeOf(other))) {
     var msg = ('type ' + this.name + ' is not a subtype of ' + other.name + '');
     if ($notnull_bool(typeErrors)) {
       world.error($assert_String(msg), span);
     }
     else {
       world.warning($assert_String(msg), span);
     }
   }
 }
-Type.prototype.needsVarCall = function(args) {
+lang_Type.prototype.needsVarCall = function(args) {
   if ($notnull_bool(this.get$isVarOrFunction())) {
     return true;
   }
   var call = this.getCallMethod();
   if ($notnull_bool($ne(call, null))) {
     if (args.get$length() != call.get$parameters().length || !$notnull_bool(call.namesInOrder$1(args))) {
       return true;
     }
   }
   return false;
 }
-Type.union = function(x, y) {
+lang_Type.union = function(x, y) {
   if ($eq(x, y)) return x;
   if ($notnull_bool(x.get$isNum()) && $notnull_bool(y.get$isNum())) return world.numType;
   if ($notnull_bool(x.get$isString()) && $notnull_bool(y.get$isString())) return world.stringType;
   return world.varType;
 }
-Type.prototype.isAssignable = function(other) {
+lang_Type.prototype.isAssignable = function(other) {
   return $notnull_bool(this.isSubtypeOf(other)) || $notnull_bool(other.isSubtypeOf(this));
 }
-Type.prototype._isDirectSupertypeOf = function(other) {
+lang_Type.prototype._isDirectSupertypeOf = function(other) {
   var $this = this; // closure support
   if ($notnull_bool(other.get$isClass())) {
     return $eq(other.get$parent(), this) || $notnull_bool(this.get$isObject()) && other.get$parent() == null;
   }
   else {
     if (other.get$interfaces() == null || other.get$interfaces().isEmpty()) {
       return this.get$isObject();
     }
     else {
       return other.get$interfaces().some((function (i) {
         return $eq(i, $this);
       })
       );
     }
   }
 }
-Type.prototype.isSubtypeOf = function(other) {
+lang_Type.prototype.isSubtypeOf = function(other) {
   if ((other instanceof ParameterType)) {
     return true;
   }
   if ($eq(this, other)) return true;
   if ($notnull_bool(this.get$isVar())) return true;
   if ($notnull_bool(other.get$isVar())) return true;
   if ($notnull_bool(other._isDirectSupertypeOf(this))) return true;
   var call = this.getCallMethod();
   var otherCall = other.getCallMethod();
   if ($notnull_bool($ne(call, null)) && $notnull_bool($ne(otherCall, null))) {
-    return Type._isFunctionSubtypeOf((call && call.is$MethodMember()), (otherCall && otherCall.is$MethodMember()));
+    return lang_Type._isFunctionSubtypeOf((call && call.is$MethodMember()), (otherCall && otherCall.is$MethodMember()));
   }
   if ($eq(this.get$genericType(), other.get$genericType()) && $notnull_bool($ne(this.get$typeArgsInOrder(), null)) && $notnull_bool($ne(other.get$typeArgsInOrder(), null)) && this.get$typeArgsInOrder().length == other.get$typeArgsInOrder().length) {
     var t = this.get$typeArgsInOrder().iterator$0();
     var s = other.get$typeArgsInOrder().iterator$0();
     while ($notnull_bool(t.hasNext$0())) {
       if (!$notnull_bool(t.next$0().isSubtypeOf$1(s.next$0()))) return false;
     }
     return true;
   }
   if (this.get$parent() != null && $notnull_bool(this.get$parent().isSubtypeOf(other))) {
     return true;
   }
   if (this.get$interfaces() != null && this.get$interfaces().some((function (i) {
     return i.isSubtypeOf$1(other);
   })
   )) {
     return true;
   }
   return false;
 }
-Type._isFunctionSubtypeOf = function(t, s) {
+lang_Type._isFunctionSubtypeOf = function(t, s) {
   if (!$notnull_bool(s.returnType.get$isVoid()) && !$notnull_bool(s.returnType.isAssignable(t.returnType))) {
     return false;
   }
   var tp = t.parameters;
   var sp = s.parameters;
   if (tp.length < sp.length) return false;
   for (var i = 0;
    i < sp.length; i++) {
     if ($ne(tp.$index(i).get$isOptional(), sp.$index(i).get$isOptional())) return false;
     if ($notnull_bool(tp.$index(i).get$isOptional()) && $notnull_bool($ne(tp.$index(i).get$name(), sp.$index(i).get$name()))) return false;
     if (!$notnull_bool(tp.$index(i).type.isAssignable$1(sp.$index(i).type))) return false;
   }
   if (tp.length > sp.length && !$notnull_bool(tp.$index(sp.length).get$isOptional())) return false;
   return true;
 }
-Type.prototype.addDirectSubtype$1 = function($0) {
-  return this.addDirectSubtype(($0 && $0.is$Type()));
+lang_Type.prototype.addDirectSubtype$1 = function($0) {
+  return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
-Type.prototype.ensureSubtypeOf$3 = function($0, $1, $2) {
-  return this.ensureSubtypeOf(($0 && $0.is$Type()), ($1 && $1.is$SourceSpan()), $assert_bool($2));
+lang_Type.prototype.ensureSubtypeOf$3 = function($0, $1, $2) {
+  return this.ensureSubtypeOf(($0 && $0.is$lang_Type()), ($1 && $1.is$SourceSpan()), $assert_bool($2));
 };
-Type.prototype.getConstructor$1 = function($0) {
+lang_Type.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
-Type.prototype.getFactory$2 = function($0, $1) {
-  return this.getFactory(($0 && $0.is$Type()), $assert_String($1));
+lang_Type.prototype.getFactory$2 = function($0, $1) {
+  return this.getFactory(($0 && $0.is$lang_Type()), $assert_String($1));
 };
-Type.prototype.getMember$1 = function($0) {
+lang_Type.prototype.getMember$1 = function($0) {
   return this.getMember($assert_String($0));
 };
-Type.prototype.getOrMakeConcreteType$1 = function($0) {
+lang_Type.prototype.getOrMakeConcreteType$1 = function($0) {
   return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
 };
-Type.prototype.hashCode$0 = function() {
+lang_Type.prototype.hashCode$0 = function() {
   return this.hashCode();
 };
-Type.prototype.isAssignable$1 = function($0) {
-  return this.isAssignable(($0 && $0.is$Type()));
+lang_Type.prototype.isAssignable$1 = function($0) {
+  return this.isAssignable(($0 && $0.is$lang_Type()));
 };
-Type.prototype.isSubtypeOf$1 = function($0) {
-  return this.isSubtypeOf(($0 && $0.is$Type()));
+lang_Type.prototype.isSubtypeOf$1 = function($0) {
+  return this.isSubtypeOf(($0 && $0.is$lang_Type()));
 };
-Type.prototype.markUsed$0 = function() {
+lang_Type.prototype.markUsed$0 = function() {
   return this.markUsed();
 };
-Type.prototype.resolveMember$1 = function($0) {
+lang_Type.prototype.resolveMember$1 = function($0) {
   return this.resolveMember($assert_String($0));
 };
-Type.prototype.resolveTypeParams$1 = function($0) {
+lang_Type.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 // ********** Code for ParameterType **************
 function ParameterType(name, typeParameter) {
   this.typeParameter = typeParameter;
   // Initializers done
-  Type.call(this, name);
+  lang_Type.call(this, name);
 }
-$inherits(ParameterType, Type);
+$inherits(ParameterType, lang_Type);
 ParameterType.prototype.is$ParameterType = function(){return this;};
 ParameterType.prototype.get$isClass = function() {
   return false;
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
 ParameterType.prototype.get$span = function() {
   return this.typeParameter.span;
 }
@@ skipping 13 matching lines @@
   return this.extendsType.resolveMember(memberName);
 }
 ParameterType.prototype.getConstructor = function(constructorName) {
   world.internalError('no constructors on type parameters yet');
 }
 ParameterType.prototype.getOrMakeConcreteType = function(typeArgs) {
   world.internalError('no concrete types of type parameters yet', this.get$span());
 }
 ParameterType.prototype.resolveTypeParams = function(inType) {
   var $0;
-  return (($0 = inType.typeArguments.$index(this.name)) && $0.is$Type());
+  return (($0 = inType.typeArguments.$index(this.name)) && $0.is$lang_Type());
 }
 ParameterType.prototype.addDirectSubtype = function(type) {
   world.internalError('no subtypes of type parameters yet', this.get$span());
 }
 ParameterType.prototype.resolve = function(inType) {
   if (this.typeParameter.extendsType != null) {
     this.extendsType = inType.resolveType(this.typeParameter.extendsType, true);
   }
   else {
     this.extendsType = world.objectType;
   }
 }
 ParameterType.prototype.addDirectSubtype$1 = function($0) {
-  return this.addDirectSubtype(($0 && $0.is$Type()));
+  return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 ParameterType.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
 ParameterType.prototype.getOrMakeConcreteType$1 = function($0) {
   return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
 };
 ParameterType.prototype.isSubtypeOf$1 = function($0) {
-  return this.isSubtypeOf(($0 && $0.is$Type()));
+  return this.isSubtypeOf(($0 && $0.is$lang_Type()));
 };
 ParameterType.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$Type()));
+  return this.resolve(($0 && $0.is$lang_Type()));
 };
 ParameterType.prototype.resolveMember$1 = function($0) {
   return this.resolveMember($assert_String($0));
 };
 ParameterType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 // ********** Code for NonNullableType **************
 function NonNullableType(type) {
   this.type = type;
   // Initializers done
-  Type.call(this, type.name);
+  lang_Type.call(this, type.name);
 }
-$inherits(NonNullableType, Type);
+$inherits(NonNullableType, lang_Type);
 NonNullableType.prototype.get$type = function() { return this.type; };
 NonNullableType.prototype.get$isNullable = function() {
   return false;
 }
 NonNullableType.prototype.get$isBool = function() {
   return this.type.get$isBool();
 }
 NonNullableType.prototype.get$isUsed = function() {
   return false;
 }
@@ skipping 84 matching lines @@
 NonNullableType.prototype.get$parent = function() {
   return this.type.get$parent();
 }
 NonNullableType.prototype.getAllMembers = function() {
   return this.type.getAllMembers();
 }
 NonNullableType.prototype.get$isNativeType = function() {
   return this.type.get$isNativeType();
 }
 NonNullableType.prototype.addDirectSubtype$1 = function($0) {
-  return this.addDirectSubtype(($0 && $0.is$Type()));
+  return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 NonNullableType.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
 NonNullableType.prototype.getFactory$2 = function($0, $1) {
-  return this.getFactory(($0 && $0.is$Type()), $assert_String($1));
+  return this.getFactory(($0 && $0.is$lang_Type()), $assert_String($1));
 };
 NonNullableType.prototype.getMember$1 = function($0) {
   return this.getMember($assert_String($0));
 };
 NonNullableType.prototype.getOrMakeConcreteType$1 = function($0) {
   return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
 };
 NonNullableType.prototype.isSubtypeOf$1 = function($0) {
-  return this.isSubtypeOf(($0 && $0.is$Type()));
+  return this.isSubtypeOf(($0 && $0.is$lang_Type()));
 };
 NonNullableType.prototype.markUsed$0 = function() {
   return this.markUsed();
 };
 NonNullableType.prototype.resolveMember$1 = function($0) {
   return this.resolveMember($assert_String($0));
 };
 NonNullableType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 // ********** 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();
   // Initializers done
-  Type.call(this, name);
+  lang_Type.call(this, name);
 }
-$inherits(ConcreteType, Type);
+$inherits(ConcreteType, lang_Type);
 ConcreteType.prototype.is$ConcreteType = function(){return this;};
 ConcreteType.prototype.get$genericType = function() { return this.genericType; };
 ConcreteType.prototype.get$typeArgsInOrder = function() { return this.typeArgsInOrder; };
 ConcreteType.prototype.set$typeArgsInOrder = function(value) { return this.typeArgsInOrder = value; };
 ConcreteType.prototype.get$isList = function() {
   return this.genericType.get$isList();
 }
 ConcreteType.prototype.get$isClass = function() {
   return this.genericType.isClass;
 }
@@ skipping 110 matching lines @@
   var $list = this.genericType.get$subtypes();
   for (var $i = this.genericType.get$subtypes().iterator(); $i.hasNext$0(); ) {
     var t = $i.next$0();
     var m = t.get$members().$index(memberName);
     if ($notnull_bool($ne(m, null))) ret.add$1(m);
   }
   return (ret && ret.is$MemberSet());
 }
 ConcreteType.prototype.resolveType = function(node, isRequired) {
   var ret = this.genericType.resolveType(node, isRequired);
-  return (ret && ret.is$Type());
+  return (ret && ret.is$lang_Type());
 }
 ConcreteType.prototype.addDirectSubtype = function(type) {
   this.genericType.addDirectSubtype(type);
 }
 ConcreteType.prototype.addDirectSubtype$1 = function($0) {
-  return this.addDirectSubtype(($0 && $0.is$Type()));
+  return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 ConcreteType.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
 ConcreteType.prototype.getFactory$2 = function($0, $1) {
-  return this.getFactory(($0 && $0.is$Type()), $assert_String($1));
+  return this.getFactory(($0 && $0.is$lang_Type()), $assert_String($1));
 };
 ConcreteType.prototype.getMember$1 = function($0) {
   return this.getMember($assert_String($0));
 };
 ConcreteType.prototype.getOrMakeConcreteType$1 = function($0) {
   return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
 };
 ConcreteType.prototype.markUsed$0 = function() {
   return this.markUsed();
 };
 ConcreteType.prototype.resolveMember$1 = function($0) {
   return this.resolveMember($assert_String($0));
 };
 ConcreteType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 // ********** Code for DefinedType **************
 function DefinedType(name, library, definition, isClass) {
   this.isUsed = false
   this.isNativeType = false
   this.library = library;
   this.isClass = isClass;
   this.directSubtypes = new HashSetImplementation();
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
   this._resolvedMembers = $map([]);
   // Initializers done
-  Type.call(this, name);
+  lang_Type.call(this, name);
   this.setDefinition(definition);
 }
-$inherits(DefinedType, Type);
+$inherits(DefinedType, lang_Type);
 DefinedType.prototype.is$DefinedType = function(){return this;};
 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(p) {
   this._parent = p;
@@ skipping 485 matching lines @@
       name = $assert_String(typeRef.names.last().get$name());
     }
     else {
       name = typeRef.name.name;
     }
     if (this.typeParameters != null) {
       var $list = this.typeParameters;
       for (var $i = 0;$i < $list.length; $i++) {
         var tp = $list.$index($i);
         if ($notnull_bool($eq(tp.get$name(), name))) {
-          typeRef.type = (tp && tp.is$Type());
+          typeRef.type = (tp && tp.is$lang_Type());
         }
       }
     }
     if (typeRef.type == null) {
       typeRef.type = this.library.findType(typeRef);
     }
     if (typeRef.type == null) {
       var message = ('can not find type ' + DefinedType._getDottedName(typeRef) + '');
       if ($notnull_bool(typeErrors)) {
         world.error($assert_String(message), typeRef.span);
@@ skipping 51 matching lines @@
     var paramName = this.typeParameters.$index(i).get$name();
     typeMap.$setindex(paramName, typeArgs.$index(i));
     names.add$1(typeArgs.$index(i).get$name());
   }
   var concreteName = Strings.join((names && names.is$List$String()), '\$');
   var ret = this._concreteTypes.$index(concreteName);
   if ($notnull_bool(ret == null)) {
     ret = new ConcreteType($assert_String(concreteName), this, typeMap, typeArgs);
     this._concreteTypes.$setindex(concreteName, ret);
   }
-  return (ret && ret.is$Type());
+  return (ret && ret.is$lang_Type());
 }
 DefinedType.prototype.getCallStub = function(args) {
   $assert(this.get$isFunction(), "isFunction", "type.dart", 1251, 12);
   var name = _getCallStubName('call', args);
   if (this.varStubs == null) this.varStubs = $map([]);
   var stub = this.varStubs.$index(name);
   if ($notnull_bool(stub == null)) {
     stub = new VarFunctionStub($assert_String(name), args);
     this.varStubs.$setindex(name, stub);
   }
   return (stub && stub.is$VarFunctionStub());
 }
 DefinedType.prototype.addDirectSubtype$1 = function($0) {
-  return this.addDirectSubtype(($0 && $0.is$Type()));
+  return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 DefinedType.prototype.addMethod$2 = function($0, $1) {
   return this.addMethod($assert_String($0), ($1 && $1.is$FunctionDefinition()));
 };
 DefinedType.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
 DefinedType.prototype.getFactory$2 = function($0, $1) {
-  return this.getFactory(($0 && $0.is$Type()), $assert_String($1));
+  return this.getFactory(($0 && $0.is$lang_Type()), $assert_String($1));
 };
 DefinedType.prototype.getMember$1 = function($0) {
   return this.getMember($assert_String($0));
 };
 DefinedType.prototype.getOrMakeConcreteType$1 = function($0) {
   return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
 };
 DefinedType.prototype.markUsed$0 = function() {
   return this.markUsed();
 };
@@ skipping 394 matching lines @@
   else {
     if (argsString.length > 0) argsString = (', ' + argsString + '');
     world.gen.corejs.useOperator(name);
     return new Value(returnType, ('' + name + '(' + this.code + '' + argsString + ')'), this.span, true);
   }
 }
 Value.prototype.checkFirstClass$1 = function($0) {
   return this.checkFirstClass(($0 && $0.is$SourceSpan()));
 };
 Value.prototype.convertTo$3 = function($0, $1, $2) {
-  return this.convertTo(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Type()), ($2 && $2.is$Node()), false);
+  return this.convertTo(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Type()), ($2 && $2.is$lang_Node()), false);
 };
 Value.prototype.convertTo$4 = function($0, $1, $2, $3) {
-  return this.convertTo(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Type()), ($2 && $2.is$Node()), $assert_bool($3));
+  return this.convertTo(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Type()), ($2 && $2.is$lang_Node()), $assert_bool($3));
 };
 Value.prototype.get_$3 = function($0, $1, $2) {
-  return this.get_(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$Node()));
+  return this.get_(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$lang_Node()));
 };
 Value.prototype.instanceOf$3$isTrue$forceCheck = function($0, $1, $2, isTrue, forceCheck) {
-  return this.instanceOf(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Type()), ($2 && $2.is$SourceSpan()), $assert_bool(isTrue), $assert_bool(forceCheck));
+  return this.instanceOf(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Type()), ($2 && $2.is$SourceSpan()), $assert_bool(isTrue), $assert_bool(forceCheck));
 };
 Value.prototype.instanceOf$4 = function($0, $1, $2, $3) {
-  return this.instanceOf(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Type()), ($2 && $2.is$SourceSpan()), $assert_bool($3), false);
+  return this.instanceOf(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Type()), ($2 && $2.is$SourceSpan()), $assert_bool($3), false);
 };
 Value.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$Node()), ($3 && $3.is$Arguments()), false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$lang_Node()), ($3 && $3.is$Arguments()), false);
 };
 Value.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$Node()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
+  return this.invoke(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$lang_Node()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 Value.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$Node()), ($3 && $3.is$Arguments()), $assert_bool($4));
+  return this.invoke(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$lang_Node()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
 Value.prototype.needsConversion$1 = function($0) {
-  return this.needsConversion(($0 && $0.is$Type()));
+  return this.needsConversion(($0 && $0.is$lang_Type()));
 };
 Value.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$Node()), ($3 && $3.is$Value()), false);
+  return this.set_(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$lang_Node()), ($3 && $3.is$Value()), false);
 };
 // ********** Code for EvaluatedValue **************
 function EvaluatedValue() {}
 EvaluatedValue._internal$ctor = function(type, actualValue, canonicalCode, span, code) {
   this.actualValue = actualValue;
   this.canonicalCode = canonicalCode;
   // Initializers done
   Value.call(this, type, code, span, false);
 }
 EvaluatedValue._internal$ctor.prototype = EvaluatedValue.prototype;
 $inherits(EvaluatedValue, Value);
 EvaluatedValue.EvaluatedValue$factory = function(type, actualValue, canonicalCode, span) {
   return new EvaluatedValue._internal$ctor(type, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 EvaluatedValue.prototype.get$actualValue = function() { return this.actualValue; };
 EvaluatedValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
 EvaluatedValue.prototype.get$isConst = function() {
   return true;
 }
 EvaluatedValue.prototype.get$canonicalCode = function() { return this.canonicalCode; };
 EvaluatedValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
 EvaluatedValue.codeWithComments = function(canonicalCode, span) {
   return (span != null && span.get$text() != canonicalCode) ? ('' + canonicalCode + '/*' + span.get$text() + '*/') : canonicalCode;
 }
 // ********** Code for ConstListValue **************
 function ConstListValue() {}
 ConstListValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
   this.values = values;
   // Initializers done
-  EvaluatedValue._internal$ctor.call(this, (type && type.is$Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
+  EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
 }
 ConstListValue._internal$ctor.prototype = ConstListValue.prototype;
 $inherits(ConstListValue, EvaluatedValue);
 ConstListValue.ConstListValue$factory = function(type, values, actualValue, canonicalCode, span) {
   return new ConstListValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 // ********** Code for ConstMapValue **************
 function ConstMapValue() {}
 ConstMapValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
   this.values = values;
   // Initializers done
-  EvaluatedValue._internal$ctor.call(this, (type && type.is$Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
+  EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
 }
 ConstMapValue._internal$ctor.prototype = ConstMapValue.prototype;
 $inherits(ConstMapValue, EvaluatedValue);
 ConstMapValue.ConstMapValue$factory = function(type, keyValuePairs, actualValue, canonicalCode, span) {
   var values = new HashMapImplementation();
   for (var i = 0;
    i < keyValuePairs.length; i += 2) {
     values.$setindex(keyValuePairs.$index(i).get$actualValue(), keyValuePairs.$index(i + 1));
   }
   return new ConstMapValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 // ********** Code for ConstObjectValue **************
 function ConstObjectValue() {}
 ConstObjectValue._internal$ctor = function(type, fields, actualValue, canonicalCode, span, code) {
   this.fields = fields;
   // Initializers done
-  EvaluatedValue._internal$ctor.call(this, (type && type.is$Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
+  EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
 }
 ConstObjectValue._internal$ctor.prototype = ConstObjectValue.prototype;
 $inherits(ConstObjectValue, EvaluatedValue);
 ConstObjectValue.ConstObjectValue$factory = function(type, fields, canonicalCode, span) {
   var fieldValues = [];
   var $list = fields.getKeys();
   for (var $i = fields.getKeys().iterator$0(); $i.hasNext$0(); ) {
     var f = $i.next$0();
     fieldValues.add(('' + f + ' = ' + fields.$index(f).get$actualValue() + ''));
   }
@@ skipping 253 matching lines @@
       throw exc;
     }
   }
   this.printStatus();
   return !$notnull_bool(this.get$hasErrors());
 }
 World.prototype.runLeg = function() {
   var $this = this; // closure support
   if (!$notnull_bool(options.enableLeg)) return false;
   var res = $assert_bool(this.withTiming('try leg compile', (function () {
-    return leg_compile($this);
+    return compile($this);
   })
   ));
   if (!$notnull_bool(res) && $notnull_bool(options.legOnly)) {
     this.fatal(("Leg could not compile " + options.dartScript + ""));
     return true;
   }
   return res;
 }
 World.prototype.runCompilationPhases = function() {
   var $this = this; // closure support
@@ skipping 273 matching lines @@
       this.libDir = $assert_String(temp);
     }
     else {
       this.libDir = 'lib';
     }
   }
 }
 // ********** Code for LibraryReader **************
 function LibraryReader() {
   // Initializers done
-  this._specialLibs = $map(['dart:core', joinPaths(options.libDir, 'corelib.dart'), 'dart:coreimpl', joinPaths(options.libDir, 'corelib_impl.dart'), 'dart:html', joinPaths(options.libDir, '../../client/html/release/html.dart'), 'dart:dom', joinPaths(options.libDir, 'dom/dom.dart'), 'dart:json', joinPaths(options.libDir, 'json.dart')]);
+  this._specialLibs = $map(['dart:core', joinPaths(options.libDir, 'corelib.dart'), 'dart:coreimpl', joinPaths(options.libDir, 'corelib_impl.dart'), 'dart:html', joinPaths(options.libDir, '../../client/html/release/html.dart'), 'dart:dom', joinPaths(options.libDir, '../../client/dom/frog/frog_dom.dart'), 'dart:json', joinPaths(options.libDir, 'json.dart')]);
 }
 LibraryReader.prototype.readFile = function(fullname) {
   var filename = this._specialLibs.$index(fullname);
   if ($notnull_bool(filename == null)) {
     filename = fullname;
   }
   if ($notnull_bool(world.files.fileExists($assert_String(filename)))) {
     return new SourceFile(filename, world.files.readAll($assert_String(filename)));
   }
   else {
@@ skipping 11 matching lines @@
 VarMember.prototype.get$returnType = function() {
   return world.varType;
 }
 VarMember.prototype.invoke = function(context, node, target, args) {
   return new Value(this.get$returnType(), ('' + target.code + '.' + this.name + '(' + args.getCode() + ')'), node.span, true);
 }
 VarMember.prototype.generate$1 = function($0) {
   return this.generate(($0 && $0.is$CodeWriter()));
 };
 VarMember.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()));
 };
 // ********** Code for VarFunctionStub **************
 function VarFunctionStub(name, callArgs) {
   this.args = callArgs.toCallStubArgs();
   // Initializers done
   VarMember.call(this, name);
   world.gen.corejs.useGenStub = true;
 }
 $inherits(VarFunctionStub, VarMember);
 VarFunctionStub.prototype.is$VarFunctionStub = function(){return this;};
@@ skipping 33 matching lines @@
 function VarMethodStub(name, member, args, body) {
   this.member = member;
   this.args = args;
   this.body = body;
   // Initializers done
   VarMember.call(this, name);
 }
 $inherits(VarMethodStub, VarMember);
 VarMethodStub.prototype.get$returnType = function() {
   var $0;
-  return (($0 = this.member != null ? this.member.get$returnType() : world.varType) && $0.is$Type());
+  return (($0 = this.member != null ? this.member.get$returnType() : world.varType) && $0.is$lang_Type());
 }
 VarMethodStub.prototype.get$typeName = function() {
   return this.member != null ? this.member.declaringType.get$jsname() : 'Object';
 }
 VarMethodStub.prototype.generate = function(code) {
   code.write(('' + this.get$typeName() + '.prototype.' + this.name + ' = '));
   this.generateBody(code, ';');
 }
 VarMethodStub.prototype.generateBody = function(code, end) {
   if ($notnull_bool(this._useDirectCall(this.member, this.args))) {
@@ skipping 55 matching lines @@
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
     var target = new Value(member.declaringType, 'this', node.span, true);
     var result = member.invoke$4$isDynamic(context, node, target, this.args, true);
     var stub = new VarMethodStub(this.name, member, this.args, result);
     var type = member.declaringType;
     if ($notnull_bool(type.get$isObject())) {
       objectStub = stub;
     }
     else if ($ne(type.get$library(), world.get$dom())) {
-      VarMethodSet._addVarStub((type && type.is$Type()), (stub && stub.is$VarMember()));
+      VarMethodSet._addVarStub((type && type.is$lang_Type()), (stub && stub.is$VarMember()));
     }
     else {
       this._fallbackStubs.add(stub);
     }
   }
   if ($notnull_bool(objectStub == null)) {
     var target = new Value(world.objectType, 'this', node.span, true);
     var result = target.invokeNoSuchMethod(context, this.get$baseName(), node, this.args);
     objectStub = new VarMethodStub(this.name, null, this.args, result);
   }
@@ skipping 18 matching lines @@
     var stub = $list.$index($i);
     code.write(('"' + stub.get$typeName() + '": '));
     stub.generateBody$2(code, $notnull_bool($eq(stub, lastOne)) ? '' : ',');
   }
   code.exitBlock('});');
 }
 VarMethodSet.prototype.generate$1 = function($0) {
   return this.generate(($0 && $0.is$CodeWriter()));
 };
 VarMethodSet.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()));
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()));
 };
 // ********** Code for top level **************
 function map(source, mapper) {
   var result = new ListFactory();
   if (!!(source && source.is$List)) {
     var list = (source && source.is$List());
     result.length = list.length;
     for (var i = 0;
      i < list.length; i++) {
       result.$setindex(i, mapper(list.$index(i)));
@@ skipping 70 matching lines @@
   else {
     return text;
   }
 }
 var world;
 function initializeWorld(files) {
   $assert(world == null, "world == null", "world.dart", 13, 10);
   world = new World(files);
   world.init();
 }
-function compile(homedir, args, files) {
+function lang_compile(homedir, args, files) {
   parseOptions(homedir, args, files);
   initializeWorld(files);
   var success = world.compile();
   if (options.outfile != null) {
     if ($notnull_bool(success)) {
       var code = world.getGeneratedCode();
       if (!options.outfile.endsWith('.js')) {
         code = '#!/usr/bin/env node\n' + code;
       }
       world.files.writeString(options.outfile, $assert_String(code));
@@ skipping 15 matching lines @@
    i < args.get$length(); i++) {
     nameBuilder.add('\$').add(args.getName(i));
   }
   return nameBuilder.toString();
 }
 //  ********** Library frog **************
 // ********** Code for top level **************
 function main() {
   var homedir = path.dirname(fs.realpathSync($assert_String(process.argv.$index(1))));
   var argv = ListFactory.ListFactory$from$factory(process.argv);
-  if ($notnull_bool(compile($assert_String(homedir), (argv && argv.is$List$String()), new NodeFileSystem()))) {
+  if ($notnull_bool(lang_compile($assert_String(homedir), (argv && argv.is$List$String()), new NodeFileSystem()))) {
     var code = world.getGeneratedCode();
     if (!$notnull_bool(options.compileOnly)) {
       process.argv = [argv.$index(0), argv.$index(1)];
       process.argv.addAll(options.childArgs);
       vm.runInNewContext($assert_String(code), createSandbox());
     }
   }
   else {
     process.exit(1);
   }
@@ skipping 287 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();