Create class AST nodes.

dart/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 189 matching lines @@
 AssertError.prototype.toString = function() {
   return ("Failed assertion: '" + this.failedAssertion + "' is not true ") + ("in " + this.url + " at line " + this.line + ", column " + this.column + ".");
 }
 // ********** Code for Object **************
 Object.prototype.get$dynamic = function() {
   return this;
 }
 Object.prototype.noSuchMethod = function(name, args) {
   $throw(new NoSuchMethodException(this, name, args));
 }
+Object.prototype.beginTypeArguments$1 = function($0) {
+  return this.noSuchMethod("beginTypeArguments", [$0]);
+}
+;
+Object.prototype.beginTypeVariables$1 = function($0) {
+  return this.noSuchMethod("beginTypeVariables", [$0]);
+}
+;
+Object.prototype.endTypeArguments$3 = function($0, $1, $2) {
+  return this.noSuchMethod("endTypeArguments", [$0, $1, $2]);
+}
+;
+Object.prototype.endTypeVariables$3 = function($0, $1, $2) {
+  return this.noSuchMethod("endTypeVariables", [$0, $1, $2]);
+}
+;
 Object.prototype.get_$3 = function($0, $1, $2) {
   return this.noSuchMethod("get_", [$0, $1, $2]);
 }
 ;
+Object.prototype.handleNoTypeArguments$1 = function($0) {
+  return this.noSuchMethod("handleNoTypeArguments", [$0]);
+}
+;
+Object.prototype.handleNoTypeVariables$1 = function($0) {
+  return this.noSuchMethod("handleNoTypeVariables", [$0]);
+}
+;
 Object.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("invoke", [$0, $1, $2, $3]);
 }
 ;
 Object.prototype.set_$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("set_", [$0, $1, $2, $3]);
 }
 ;
 Object.prototype.visitPostfixExpression$1 = function($0) {
   return this.noSuchMethod("visitPostfixExpression", [$0]);
@@ skipping 89 matching lines @@
 function to$call$1(f) { return f && f.to$call$1(); }
 Function.prototype.to$call$2 = function() {
   this.call$2 = this.$genStub(2);
   this.to$call$2 = function() { return this.call$2; };
   return this.call$2;
 };
 Function.prototype.call$2 = function($0, $1) {
   return this.to$call$2()($0, $1);
 };
 function to$call$2(f) { return f && f.to$call$2(); }
+Function.prototype.to$call$3 = function() {
+  this.call$3 = this.$genStub(3);
+  this.to$call$3 = function() { return this.call$3; };
+  return this.call$3;
+};
+Function.prototype.call$3 = function($0, $1, $2) {
+  return this.to$call$3()($0, $1, $2);
+};
+function to$call$3(f) { return f && f.to$call$3(); }
 // ********** Code for Math **************
 Math.parseInt = function(str) {
   var ret = parseInt(str);
     if (isNaN(ret)) $throw(new BadNumberFormatException(str));
     return ret;
 }
 Math.parseDouble = function(str) {
   var ret = parseFloat(str);
     if (isNaN(ret) && str != 'NaN') $throw(new BadNumberFormatException(str));
     return ret;
@@ skipping 4836 matching lines @@
     for (var link = elements;
      $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Element())) {
       $this.compiler.universe.define((($0 = link.get$head()) && $0.is$Element()));
     }
   })
   );
 }
 ScannerTask.prototype.scanElements = function(text) {
   var tokens = new StringScanner(text).tokenize();
   var listener = new ElementListener(this.compiler);
-  var parser = new Parser(listener);
+  var parser = new PartialParser(listener);
   parser.parseUnit(tokens);
   return listener.topLevelElements;
 }
-// ********** Code for Parser **************
-function Parser(listener) {
+// ********** Code for PartialParser **************
+function PartialParser(listener) {
   this.listener = listener;
   // Initializers done
+  this.beginTypeArguments = this.listener.beginTypeArguments;
+  this.parseTypeFunction = this.get$parseType();
+  this.endTypeArguments = this.listener.endTypeArguments;
+  this.handleNoTypeArguments = this.listener.handleNoTypeArguments;
+  this.beginTypeVariables = this.listener.beginTypeVariables;
+  this.parseTypeVariableFunction = this.get$parseTypeVariable();
+  this.endTypeVariables = this.listener.endTypeVariables;
+  this.handleNoTypeVariables = this.listener.handleNoTypeVariables;
+  if ($notnull_bool(this.parseTypeFunction == null)) {
+    this.listener.beginTypeArguments$1();
+    this.listener.endTypeArguments$3(0);
+    this.listener.handleNoTypeArguments$1();
+    this.listener.beginTypeVariables$1();
+    this.parseTypeVariable(null);
+    this.listener.endTypeVariables$3(0);
+    this.listener.handleNoTypeVariables$1();
+  }
 }
-Parser.prototype.next = function(token) {
+PartialParser.prototype.next = function(token) {
   return this.checkEof(token.next);
 }
-Parser.prototype.checkEof = function(token) {
+PartialParser.prototype.checkEof = function(token) {
   if ($notnull_bool(token.kind === 0/*null.EOF_TOKEN*/)) {
     this.listener.unexpectedEof();
     $throw('Unexpected EOF');
   }
   return token;
 }
-Parser.prototype.parseUnit = function(token) {
+PartialParser.prototype.parseUnit = function(token) {
   while ($notnull_bool(token.kind !== 0/*null.EOF_TOKEN*/)) {
     var value = token.get$stringValue();
     switch (true) {
       case value === 'interface':
 
         token = this.parseInterface(token);
         break;
 
       case value === 'class':
 
@@ skipping 11 matching lines @@
         break;
 
       default:
 
         token = this.parseTopLevelMember(token);
         break;
 
     }
   }
 }
-Parser.prototype.parseInterface = function(token) {
+PartialParser.prototype.parseInterface = function(token) {
   this.listener.beginInterface(token);
   token = this.parseIdentifier(this.next(token));
   token = this.parseTypeVariablesOpt(token);
   token = this.parseSupertypesClauseOpt(token);
   token = this.parseFactoryClauseOpt(token);
   return this.parseInterfaceBody(token);
 }
-Parser.prototype.parseInterfaceBody = function(token) {
+PartialParser.prototype.parseInterfaceBody = function(token) {
   token = this.skipBlock(token);
   this.listener.endInterface(token);
   return token.next;
 }
-Parser.prototype.parseNamedFunctionAlias = function(token) {
+PartialParser.prototype.parseNamedFunctionAlias = function(token) {
   this.listener.beginFunctionTypeAlias(token);
   token = this.parseReturnTypeOpt(this.next(token));
   token = this.parseIdentifier(token);
   token = this.parseTypeVariablesOpt(token);
   token = this.parseFormalParameters(token);
   this.listener.endFunctionTypeAlias(token);
   return this.expect(';', token);
 }
-Parser.prototype.parseReturnTypeOpt = function(token) {
+PartialParser.prototype.parseReturnTypeOpt = function(token) {
   if ($notnull_bool(token.get$stringValue() === 'void')) {
     this.listener.handleVoidKeyword(token);
     return this.next(token);
   }
   else {
     return this.parseTypeOpt(token);
   }
 }
-Parser.prototype.parseFormalParameters = function(token) {
+PartialParser.prototype.parseFormalParameters = function(token) {
   var begin = token;
   this.listener.beginFormalParameters(begin);
   this.expect('(', token);
   var parameterCount = 0;
   if ($notnull_bool(this.optional(')', token.next))) {
     this.listener.endFormalParameters(parameterCount, begin, token.next);
     return token.next.next;
   }
   do {
     this.listener.beginFormalParameter(token);
     token = this.parseTypeOpt(this.next(token));
     token = this.parseIdentifier(token);
     this.listener.endFormalParameter(token);
     ++parameterCount;
   }
   while ($notnull_bool(this.optional(',', token)))
   this.listener.endFormalParameters(parameterCount, begin, token);
   return this.expect(')', token);
 }
-Parser.prototype.parseTypeOpt = function(token) {
+PartialParser.prototype.parseTypeOpt = function(token) {
   var nextValue = token.next.get$stringValue();
   switch (true) {
     case nextValue === '<':
     case nextValue === '.':
     case this.isIdentifier(token.next):
 
       return this.parseType(token);
 
     default:
 
       this.listener.handleNoType(token);
       return token;
 
   }
 }
-Parser.prototype.isIdentifier = function(token) {
+PartialParser.prototype.isIdentifier = function(token) {
   var kind = token.kind;
   switch (true) {
     case kind === 97/*null.IDENTIFIER_TOKEN*/:
 
       return true;
 
     case kind === 107/*null.KEYWORD_TOKEN*/:
 
       return token.get$value().isPseudo;
 
     default:
 
       return false;
 
   }
 }
-Parser.prototype.parseSupertypesClauseOpt = function(token) {
+PartialParser.prototype.parseSupertypesClauseOpt = function(token) {
   if ($notnull_bool(this.optional('extends', token))) {
     do {
       token = this.parseType(this.next(token));
     }
     while ($notnull_bool(this.optional(',', token)))
   }
   return token;
 }
-Parser.prototype.parseFactoryClauseOpt = function(token) {
+PartialParser.prototype.parseFactoryClauseOpt = function(token) {
   if ($notnull_bool(this.optional('factory', token))) {
     return this.parseType(this.next(token));
   }
   return token;
 }
-Parser.prototype.skipBlock = function(token) {
+PartialParser.prototype.skipBlock = function(token) {
   if ($notnull_bool(!$notnull_bool(this.optional('{', token)))) {
     return this.listener.expectedBlock(token);
   }
   token = this.next(token);
   var nesting = 1;
   do {
     var kind = token.kind;
     switch (true) {
       case kind === 123/*null.LBRACE_TOKEN*/:
 
         nesting++;
         break;
 
       case kind === 125/*null.RBRACE_TOKEN*/:
 
         nesting--;
         if ($notnull_bool(nesting === 0)) {
           return token;
         }
         break;
 
     }
     token = this.next(token);
   }
   while ($notnull_bool(token != null))
   $throw('Internal error: unreachable code');
 }
-Parser.prototype.parseClass = function(token) {
+PartialParser.prototype.parseClass = function(token) {
   var begin = token;
   this.listener.beginClass(token);
   token = this.parseIdentifier(this.next(token));
   token = this.parseTypeVariablesOpt(token);
-  token = this.parseSuperclassClauseOpt(token);
-  token = this.parseImplementsOpt(token);
+  var extendsKeyword;
+  if ($notnull_bool(this.optional('extends', token))) {
+    extendsKeyword = token;
+    token = this.parseType(this.next(token));
+  }
+  else {
+    extendsKeyword = null;
+    this.listener.handleNoType(token);
+  }
+  var implementsKeyword;
+  var interfacesCount = 0;
+  if ($notnull_bool(this.optional('implements', token))) {
+    do {
+      token = this.parseType(this.next(token));
+      ++interfacesCount;
+    }
+    while ($notnull_bool(this.optional(',', token)))
+  }
   token = this.parseNativeClassClauseOpt(token);
   token = this.parseClassBody(token);
-  this.listener.endClass(begin, token);
+  this.listener.endClass(interfacesCount, begin, extendsKeyword, implementsKeyword, token);
   return token.next;
 }
-Parser.prototype.parseNativeClassClauseOpt = function(token) {
+PartialParser.prototype.parseNativeClassClauseOpt = function(token) {
   if ($notnull_bool(this.optional('native', token))) {
     return this.parseString(this.next(token));
   }
   return token;
 }
-Parser.prototype.parseString = function(token) {
+PartialParser.prototype.parseString = function(token) {
   if ($notnull_bool(token.kind === 39/*null.STRING_TOKEN*/)) {
     return this.next(token);
   }
   else {
     return this.listener.expected('string', token);
   }
 }
-Parser.prototype.parseIdentifier = function(token) {
+PartialParser.prototype.parseIdentifier = function(token) {
   if ($notnull_bool(this.isIdentifier(token))) {
     this.listener.handleIdentifier(token);
   }
   else {
     this.listener.expectedIdentifier(token);
   }
   return this.next(token);
 }
-Parser.prototype.parseTypeVariablesOpt = function(token) {
-  if ($notnull_bool(!$notnull_bool(this.optional('<', token)))) {
-    this.listener.handleNoTypeVariables(token);
-    return token;
-  }
-  return this.parseTypeVariables(token);
-}
-Parser.prototype.parseTypeVariables = function(token) {
-  this.expect('<', token);
-  this.listener.beginTypeVariables(token);
-  do {
-    token = this.parseTypeVariable(this.next(token));
-  }
-  while ($notnull_bool(this.optional(',', token)))
-  this.listener.endTypeVariables(token);
-  return this.expect('>', token);
-}
-Parser.prototype.expect = function(string, token) {
+PartialParser.prototype.expect = function(string, token) {
   if ($notnull_bool(string !== token.get$stringValue())) {
     return this.listener.expected(string, token);
   }
   return token.next;
 }
-Parser.prototype.parseTypeVariable = function(token) {
+PartialParser.prototype.parseTypeVariable = function(token) {
   this.listener.beginTypeVariable(token);
   token = this.parseIdentifier(token);
-  token = this.parseSuperclassClauseOpt(token);
+  if ($notnull_bool(this.optional('extends', token))) {
+    token = this.parseType(this.next(token));
+  }
+  else {
+    this.listener.handleNoType(token);
+  }
   this.listener.endTypeVariable(token);
   return token;
 }
-Parser.prototype.optional = function(value, token) {
+PartialParser.prototype.get$parseTypeVariable = function() {
+  return PartialParser.prototype.parseTypeVariable.bind(this);
+}
+PartialParser.prototype.optional = function(value, token) {
   return value === token.get$stringValue();
 }
-Parser.prototype.parseSuperclassClauseOpt = function(token) {
-  if ($notnull_bool(this.optional('extends', token))) {
-    return this.parseType(this.next(token));
-  }
-  return token;
-}
-Parser.prototype.parseType = function(token) {
+PartialParser.prototype.parseType = function(token) {
   if ($notnull_bool(this.isIdentifier(token))) {
     token = this.parseIdentifier(token);
     while ($notnull_bool(this.optional('.', token))) {
       token = this.parseIdentifier(this.next(token));
     }
   }
   else if ($notnull_bool(this.optional('var', token))) {
     this.listener.handleVarKeyword(token);
     this.listener.endType(token);
     return this.next(token);
   }
   else {
     token = this.listener.expectedType(token);
   }
   token = this.parseTypeArgumentsOpt(token);
   this.listener.endType(token);
   return token;
 }
-Parser.prototype.parseTypeArgumentsOpt = function(token) {
+PartialParser.prototype.get$parseType = function() {
+  return PartialParser.prototype.parseType.bind(this);
+}
+PartialParser.prototype.parseTypeArgumentsOpt = function(token) {
+  return this.parseStuff(token, this.beginTypeArguments, this.parseTypeFunction, this.endTypeArguments, this.handleNoTypeArguments);
+}
+PartialParser.prototype.parseTypeVariablesOpt = function(token) {
+  return this.parseStuff(token, this.beginTypeVariables, this.parseTypeVariableFunction, this.endTypeVariables, this.handleNoTypeVariables);
+}
+PartialParser.prototype.parseStuff = function(token, beginStuff, stuffParser, endStuff, handleNoStuff) {
+  var $0;
   if ($notnull_bool(this.optional('<', token))) {
-    this.listener.beginTypeArguments(this.next(token));
+    var begin = token;
+    beginStuff.call$1(begin);
+    var count = 0;
     do {
-      token = this.parseType(this.next(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;
 }
-Parser.prototype.parseImplementsOpt = function(token) {
-  if ($notnull_bool(this.optional('implements', token))) {
-    do {
-      token = this.parseType(this.next(token));
-    }
-    while ($notnull_bool(this.optional(',', token)))
-  }
-  return token;
-}
-Parser.prototype.parseClassBody = function(token) {
+PartialParser.prototype.parseClassBody = function(token) {
   return this.skipBlock(token);
 }
-Parser.prototype.parseTopLevelMember = function(token) {
+PartialParser.prototype.parseTopLevelMember = function(token) {
   var start = token;
   this.listener.beginTopLevelMember(token);
   var previous = token;
   LOOP:
   while ($notnull_bool(token != null)) {
     var kind = token.kind;
     switch (true) {
       case kind === 123/*null.LBRACE_TOKEN*/:
       case kind === 59/*null.SEMICOLON_TOKEN*/:
       case kind === 40/*null.LPAREN_TOKEN*/:
@@ skipping 31 matching lines @@
     token = this.skipBlock(token);
   }
   if ($notnull_bool(isField)) {
     this.listener.endTopLevelField(start, token);
   }
   else {
     this.listener.endTopLevelMethod(start, token);
   }
   return token.next;
 }
-Parser.prototype.parseLibraryTags = function(token) {
+PartialParser.prototype.parseLibraryTags = function(token) {
   this.listener.beginLibraryTag(token);
   token = this.parseIdentifier(this.next(token));
   token = this.expect('(', token);
   while ($notnull_bool(token != null && token.kind !== 40/*null.LPAREN_TOKEN*/ && token.kind !== 41/*null.RPAREN_TOKEN*/)) {
     token = this.next(token);
   }
   token = this.expect(')', token);
   return this.expect(';', token);
 }
-// ********** Code for BodyParser **************
-function BodyParser(listener) {
-  Parser.call(this, listener);
+PartialParser.prototype.beginTypeArguments$1 = function($0) {
+  return this.beginTypeArguments.call$1($0);
+}
+;
+PartialParser.prototype.beginTypeVariables$1 = function($0) {
+  return this.beginTypeVariables.call$1($0);
+}
+;
+PartialParser.prototype.endTypeArguments$3 = function($0, $1, $2) {
+  return this.endTypeArguments.call$3($0, $1, $2);
+}
+;
+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);
+}
+;
+// ********** Code for Parser **************
+function Parser(listener) {
+  PartialParser.call(this, listener);
   // Initializers done
 }
-$inherits(BodyParser, Parser);
-BodyParser.prototype.parseFunction = function(token) {
+$inherits(Parser, PartialParser);
+Parser.prototype.parseFunction = function(token) {
   this.listener.beginFunction(token);
   token = this.parseReturnTypeOpt(token);
   this.listener.beginFunctionName(token);
   token = this.parseIdentifier(token);
   this.listener.endFunctionName(token);
   token = this.parseFormalParameters(token);
   return this.parseFunctionBody(token);
 }
-BodyParser.prototype.parseFunctionBody = function(token) {
+Parser.prototype.parseFunctionBody = function(token) {
   if ($notnull_bool(this.optional(';', token))) {
     this.listener.endFunctionBody(0, null, token);
     return token.next;
   }
   var begin = token;
   var statementCount = 0;
   this.listener.beginFunctionBody(begin);
   token = this.checkEof(this.expect('{', token));
   while ($notnull_bool(!$notnull_bool(this.optional('}', token)))) {
     token = this.parseStatement(token);
     ++statementCount;
   }
   this.listener.endFunctionBody(statementCount, begin, token);
   return this.expect('}', token);
 }
-BodyParser.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);
 
   }
 }
-BodyParser.prototype.expectSemicolon = function(token) {
+Parser.prototype.expectSemicolon = function(token) {
   return this.expect(';', token);
 }
-BodyParser.prototype.parseReturnStatement = function(token) {
+Parser.prototype.parseReturnStatement = function(token) {
   var begin = token;
   this.listener.beginReturnStatement(begin);
-  $assert('return' === token.get$stringValue(), "'return' === token.stringValue", "parser.dart", 413, 12);
+  $assert('return' === token.get$stringValue(), "'return' === token.stringValue", "parser.dart", 448, 12);
   token = this.next(token);
   if ($notnull_bool(this.optional(';', token))) {
     this.listener.endReturnStatement(false, begin, token);
   }
   else {
     token = this.parseExpression(token);
     this.listener.endReturnStatement(true, begin, token);
   }
   return this.expectSemicolon(token);
 }
-BodyParser.prototype.parseExpressionStatementOrDeclaration = function(token) {
-  $assert(token.kind === 97/*null.IDENTIFIER_TOKEN*/, "token.kind === IDENTIFIER_TOKEN", "parser.dart", 425, 12);
+Parser.prototype.parseExpressionStatementOrDeclaration = function(token) {
+  $assert(token.kind === 97/*null.IDENTIFIER_TOKEN*/, "token.kind === IDENTIFIER_TOKEN", "parser.dart", 460, 12);
   var peek1 = this.next(token);
   if ($notnull_bool(peek1.kind === 97/*null.IDENTIFIER_TOKEN*/)) {
     return this.parseLocalDeclaration(token, peek1);
   }
   else {
     return this.parseExpressionStatement(token);
   }
 }
-BodyParser.prototype.parseLocalDeclaration = function(token, peek1) {
+Parser.prototype.parseLocalDeclaration = function(token, peek1) {
   var peek2 = this.next(peek1);
   if ($notnull_bool(peek2.get$stringValue() === '(')) {
     return this.parseFunction(token);
   }
   else {
     return this.parseVariablesDeclaration(token);
   }
 }
-BodyParser.prototype.parseExpressionStatement = function(token) {
+Parser.prototype.parseExpressionStatement = function(token) {
   this.listener.beginExpressionStatement(token);
   token = this.parseExpression(token);
   this.listener.endExpressionStatement(token);
   return this.expectSemicolon(token);
 }
-BodyParser.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(operator);
   }
   return token;
 }
-BodyParser.prototype.isAssignmentOperator = function(token) {
+Parser.prototype.isAssignmentOperator = function(token) {
   return 2 === this.getPrecedence(token);
 }
-BodyParser.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(question, colon);
   }
   return token;
 }
-BodyParser.prototype.parseBinaryExpression = function(token, precedence) {
-  $assert(precedence >= 4, "precedence >= 4", "parser.dart", 478, 12);
+Parser.prototype.parseBinaryExpression = function(token, precedence) {
+  $assert(precedence >= 4, "precedence >= 4", "parser.dart", 513, 12);
   token = this.parsePrimary(token);
   var tokenLevel = this.getPrecedence(token);
   for (var level = $assert_num(tokenLevel);
    $notnull_bool(level >= precedence); --level) {
     while ($notnull_bool(tokenLevel === level)) {
       var operator = token;
       token = this.parseBinaryExpression(this.next(token), level + 1);
       this.listener.handleBinaryExpression(operator);
       tokenLevel = this.getPrecedence(token);
     }
   }
   return token;
 }
-BodyParser.prototype.getPrecedence = function(token) {
+Parser.prototype.getPrecedence = function(token) {
   if ($notnull_bool(token == null)) return 0;
   var value = token.get$stringValue();
   if ($notnull_bool(value == null)) return 0;
   switch (true) {
     case value === '(':
 
       return 0;
 
     case value === '+':
 
@@ skipping 150 matching lines @@
     case value === '~/':
 
       return 13;
 
     default:
 
       return 0;
 
   }
 }
-BodyParser.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(token);
       $throw('not yet implemented');
 
   }
 }
-BodyParser.prototype.parseLiteralInt = function(token) {
+Parser.prototype.parseLiteralInt = function(token) {
   this.listener.handleLiteralInt(token);
   return token.next;
 }
-BodyParser.prototype.parseLiteralDouble = function(token) {
+Parser.prototype.parseLiteralDouble = function(token) {
   this.listener.handleLiteralDouble(token);
   return token.next;
 }
-BodyParser.prototype.parseLiteralString = function(token) {
+Parser.prototype.parseLiteralString = function(token) {
   this.listener.handleLiteralString(token);
   return token.next;
 }
-BodyParser.prototype.parseLiteralBool = function(token) {
+Parser.prototype.parseLiteralBool = function(token) {
   this.listener.handleLiteralBool(token);
   return token.next;
 }
-BodyParser.prototype.parseSend = function(token) {
+Parser.prototype.parseSend = function(token) {
   this.listener.beginSend(token);
   token = this.parseIdentifier(token);
   token = this.parseArgumentsOpt(token);
   this.listener.endSend(token);
   return token;
 }
-BodyParser.prototype.parseArgumentsOpt = function(token) {
+Parser.prototype.parseArgumentsOpt = function(token) {
   if ($notnull_bool(!$notnull_bool(this.optional('(', token)))) {
     this.listener.handleNoArguments(token);
     return token;
   }
   else {
     return this.parseArguments(token);
   }
 }
-BodyParser.prototype.parseArguments = function(token) {
+Parser.prototype.parseArguments = function(token) {
   var begin = token;
   this.listener.beginArguments(begin);
-  $assert('(' === token.get$stringValue(), "'(' === token.stringValue", "parser.dart", 611, 12);
+  $assert('(' === token.get$stringValue(), "'(' === token.stringValue", "parser.dart", 646, 12);
   var argumentCount = 0;
   if ($notnull_bool(this.optional(')', token.next))) {
     this.listener.endArguments(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(argumentCount, begin, token);
   return this.expect(')', token);
 }
-BodyParser.prototype.parseVariablesDeclaration = function(token) {
+Parser.prototype.parseVariablesDeclaration = function(token) {
   var count = 1;
   this.listener.beginVariablesDeclaration(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(count, token);
   return this.expectSemicolon(token);
 }
-BodyParser.prototype.parseOptionallyInitializedIdentifier = function(token) {
+Parser.prototype.parseOptionallyInitializedIdentifier = function(token) {
   this.listener.beginInitializedIdentifier(token);
   token = this.parseIdentifier(token);
   if ($notnull_bool(this.optional('=', token))) {
     var assignment = token;
     this.listener.beginInitializer(token);
     token = this.parseExpression(this.next(token));
     this.listener.endInitializer(assignment);
   }
   this.listener.endInitializedIdentifier();
   return token;
 }
-BodyParser.prototype.parseFinalVarOrType = function(token) {
+Parser.prototype.parseFinalVarOrType = function(token) {
   var value = token.get$stringValue();
   switch (true) {
     case 'final' === value:
 
       this.listener.handleFinalKeyword(token);
       return this.next(token);
 
     default:
 
       return this.parseType(token);
 
   }
 }
-BodyParser.prototype.parseIfStatement = function(token) {
+Parser.prototype.parseIfStatement = function(token) {
   var ifToken = token;
   this.listener.beginIfStatement(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(ifToken, elseToken);
   return token;
 }
-BodyParser.prototype.parseForStatement = function(token) {
+Parser.prototype.parseForStatement = function(token) {
   var forToken = token;
   this.listener.beginForStatement(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(forToken, token);
   return token;
 }
-BodyParser.prototype.parseBlock = function(token) {
+Parser.prototype.parseBlock = function(token) {
   var begin = token;
   this.listener.beginBlock(begin);
   var statementCount = 0;
   token = this.expect('{', token);
   while ($notnull_bool(!$notnull_bool(this.optional('}', token)))) {
     token = this.parseStatement(token);
     ++statementCount;
   }
   this.listener.endBlock(statementCount, begin, token);
   return this.expect('}', token);
 }
-BodyParser.prototype.parseThrowStatement = function(token) {
+Parser.prototype.parseThrowStatement = function(token) {
   var throwToken = token;
   this.listener.beginThrowStatement(throwToken);
   token = this.expect('throw', token);
   if ($notnull_bool(this.optional(';', token))) {
     this.listener.endRethrowStatement(throwToken, token);
     return token.next;
   }
   else {
     token = this.parseExpression(token);
     this.listener.endThrowStatement(throwToken, token);
@@ skipping 26 matching lines @@
 }
 Listener.prototype.beginBlock = function(token) {
 
 }
 Listener.prototype.endBlock = function(count, beginToken, endToken) {
 
 }
 Listener.prototype.beginClass = function(token) {
 
 }
-Listener.prototype.endClass = function(beginToken, endToken) {
+Listener.prototype.endClass = function(interfacesCount, beginToken, extendsKeyword, implementsKeyword, endToken) {
 
 }
 Listener.prototype.beginExpressionStatement = function(token) {
 
 }
 Listener.prototype.endExpressionStatement = function(token) {
 
 }
 Listener.prototype.beginFormalParameter = function(token) {
 
@@ skipping 90 matching lines @@
 }
 Listener.prototype.endTopLevelMethod = function(beginToken, endToken) {
 
 }
 Listener.prototype.endType = function(token) {
 
 }
 Listener.prototype.beginTypeArguments = function(token) {
 
 }
+Listener.prototype.endTypeArguments = function(count, beginToken, endToken) {
+
+}
+Listener.prototype.handleNoTypeArguments = function(token) {
+
+}
 Listener.prototype.beginTypeVariable = function(token) {
 
 }
 Listener.prototype.endTypeVariable = function(token) {
 
 }
 Listener.prototype.beginTypeVariables = function(token) {
 
 }
-Listener.prototype.endTypeVariables = function(token) {
+Listener.prototype.endTypeVariables = function(count, beginToken, endToken) {
 
 }
 Listener.prototype.beginVariablesDeclaration = function(token) {
 
 }
 Listener.prototype.endVariablesDeclaration = function(count, endToken) {
 
 }
 Listener.prototype.handleAssignmentExpression = function(token) {
 
@@ skipping 45 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.beginTypeArguments$1 = function($0) {
+  return this.beginTypeArguments(($0 && $0.is$Token()));
+}
+;
+Listener.prototype.beginTypeVariables$1 = function($0) {
+  return this.beginTypeVariables(($0 && $0.is$Token()));
+}
+;
+Listener.prototype.endTypeArguments$3 = function($0, $1, $2) {
+  return this.endTypeArguments($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
+}
+;
+Listener.prototype.endTypeVariables$3 = function($0, $1, $2) {
+  return this.endTypeVariables($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
+}
+;
+Listener.prototype.handleNoTypeArguments$1 = function($0) {
+  return this.handleNoTypeArguments(($0 && $0.is$Token()));
+}
+;
+Listener.prototype.handleNoTypeVariables$1 = function($0) {
+  return this.handleNoTypeVariables(($0 && $0.is$Token()));
+}
+;
 // ********** Code for ParserError **************
 function ParserError(reason) {
   this.reason = reason;
   // Initializers done
 }
 // ********** Code for ElementListener **************
 function ElementListener(canceler) {
   this.previousIdentifier = null
   this.nodes = const$236/*const EmptyLink()*/
   this.topLevelElements = const$236/*const EmptyLink()*/
   this.canceler = canceler;
   // Initializers done
 }
 $inherits(ElementListener, Listener);
 ElementListener.prototype.beginLibraryTag = function(token) {
   this.canceler.cancel("Cannot handle library tags");
 }
-ElementListener.prototype.endClass = function(beginToken, endToken) {
+ElementListener.prototype.endClass = function(interfacesCount, beginToken, extendsKeyword, implementsKeyword, endToken) {
   var $0;
-  var name;
-  while ($notnull_bool(!$notnull_bool(this.nodes.isEmpty()))) {
-    name = (($0 = this.popNode()) && $0.is$Identifier());
+  for (; $notnull_bool(interfacesCount > 0); --interfacesCount) {
+    this.popNode();
   }
+  var supertype = (($0 = this.popNode()) && $0.is$TypeAnnotation());
+  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$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 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$Identifier());
+}
 ElementListener.prototype.expected = function(string, token) {
   this.canceler.cancel(("Expected '" + string + "', but got '" + token + "' ") + ("@ " + token.charOffset + ""));
 }
 ElementListener.prototype.unexpectedEof = function() {
   this.canceler.cancel("Unexpected end of file");
 }
 ElementListener.prototype.expectedIdentifier = function(token) {
   this.canceler.cancel(("Expected identifier, but got '" + token + "' ") + ("@ " + token.charOffset + ""));
 }
 ElementListener.prototype.expectedType = function(token) {
   this.canceler.cancel(("Expected a type, but got '" + token + "' @ " + token.charOffset + ""));
 }
 ElementListener.prototype.expectedBlock = function(token) {
   this.canceler.cancel(("Expected a block, but got '" + token + "' @ " + token.charOffset + ""));
 }
 ElementListener.prototype.unexpected = function(token) {
   this.canceler.cancel(("Unexpected token '" + token + "' @ " + token.charOffset + ""));
 }
 ElementListener.prototype.pushElement = function(element) {
   var $0;
   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", 316, 12);
+  $assert(!$notnull_bool(this.nodes.isEmpty()), "!nodes.isEmpty()", "listener.dart", 330, 12);
   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) {
 
 }
-// ********** Code for BodyListener **************
-function BodyListener(canceler, logger) {
+// ********** Code for NodeListener **************
+function NodeListener(canceler, logger) {
   this.logger = logger;
   ElementListener.call(this, canceler);
   // Initializers done
   this.onError = this.get$handleOnError();
 }
-$inherits(BodyListener, ElementListener);
-BodyListener.prototype.endFormalParameter = function(token) {
+$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$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));
 }
-BodyListener.prototype.endFormalParameters = function(count, beginToken, endToken) {
+NodeListener.prototype.endFormalParameters = function(count, beginToken, endToken) {
   this.pushNode(this.makeNodeList(count, beginToken, endToken, ","));
 }
-BodyListener.prototype.endArguments = function(count, beginToken, endToken) {
+NodeListener.prototype.endArguments = function(count, beginToken, endToken) {
   this.pushNode(this.makeNodeList(count, beginToken, endToken, ","));
 }
-BodyListener.prototype.handleNoArguments = function(token) {
+NodeListener.prototype.handleNoArguments = function(token) {
   this.pushNode(null);
 }
-BodyListener.prototype.endReturnStatement = function(hasExpression, beginToken, endToken) {
+NodeListener.prototype.endReturnStatement = function(hasExpression, beginToken, endToken) {
   var $0;
   var expression = (($0 = $notnull_bool(hasExpression) ? this.popNode() : null) && $0.is$Expression());
   this.pushNode(new Return(beginToken, endToken, expression));
 }
-BodyListener.prototype.endExpressionStatement = function(token) {
+NodeListener.prototype.endExpressionStatement = function(token) {
   this.pushNode(new ExpressionStatement(this.popNode(), token));
 }
-BodyListener.prototype.handleOnError = function(token, error) {
+NodeListener.prototype.handleOnError = function(token, error) {
   this.canceler.cancel(("internal error @ " + token.charOffset + ": '" + token.get$value() + "'") + (": " + error + ""));
 }
-BodyListener.prototype.get$handleOnError = function() {
-  return BodyListener.prototype.handleOnError.bind(this);
+NodeListener.prototype.get$handleOnError = function() {
+  return NodeListener.prototype.handleOnError.bind(this);
 }
-BodyListener.prototype.handleLiteralInt = function(token) {
+NodeListener.prototype.handleLiteralInt = function(token) {
   this.pushNode(new LiteralInt(token, to$call$2(this.onError)));
 }
-BodyListener.prototype.handleLiteralDouble = function(token) {
+NodeListener.prototype.handleLiteralDouble = function(token) {
   this.pushNode(new LiteralDouble(token, to$call$2(this.onError)));
 }
-BodyListener.prototype.handleLiteralBool = function(token) {
+NodeListener.prototype.handleLiteralBool = function(token) {
   this.pushNode(new LiteralBool(token, to$call$2(this.onError)));
 }
-BodyListener.prototype.handleLiteralString = function(token) {
+NodeListener.prototype.handleLiteralString = function(token) {
   this.pushNode(new LiteralString(token));
 }
-BodyListener.prototype.handleBinaryExpression = function(token) {
+NodeListener.prototype.handleBinaryExpression = function(token) {
   var arguments = new NodeList(null, LinkFactory.Link$factory(this.popNode()), null, null);
   this.pushNode(new Send(this.popNode(), new Operator(token), arguments));
 }
-BodyListener.prototype.handleAssignmentExpression = function(token) {
+NodeListener.prototype.handleAssignmentExpression = function(token) {
   var arguments = new NodeList.singleton$ctor(this.popNode());
   var node = this.popNode();
   if ($notnull_bool(!(node instanceof Send))) this.canceler.cancel(('not assignable: ' + node + ''));
   var send = (node && node.is$Send());
   if ($notnull_bool(!$notnull_bool(send.get$isPropertyAccess()))) this.canceler.cancel(('not assignable: ' + node + ''));
   if ($notnull_bool((send instanceof SendSet))) this.canceler.cancel('chained assignment');
   this.pushNode(new SendSet(send.receiver, send.selector, token, arguments));
 }
-BodyListener.prototype.handleConditionalExpression = function(question, colon) {
+NodeListener.prototype.handleConditionalExpression = function(question, colon) {
   var elseExpression = this.popNode();
   var thenExpression = this.popNode();
   var condition = this.popNode();
   this.canceler.cancel('conditional expression not implemented yet');
 }
-BodyListener.prototype.endSend = function(token) {
+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));
 }
-BodyListener.prototype.handleVoidKeyword = function(token) {
+NodeListener.prototype.handleVoidKeyword = function(token) {
   this.pushNode(new TypeAnnotation(new Identifier(token)));
 }
-BodyListener.prototype.endFunctionBody = function(count, beginToken, endToken) {
+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));
 }
-BodyListener.prototype.handleVarKeyword = function(token) {
+NodeListener.prototype.handleVarKeyword = function(token) {
   this.pushNode(new Identifier(token));
 }
-BodyListener.prototype.handleFinalKeyword = function(token) {
+NodeListener.prototype.handleFinalKeyword = function(token) {
   this.pushNode(new Identifier(token));
 }
-BodyListener.prototype.endVariablesDeclaration = function(count, endToken) {
+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));
 }
-BodyListener.prototype.endInitializer = function(assignmentOperator) {
+NodeListener.prototype.endInitializer = function(assignmentOperator) {
   var $0;
   var initializer = (($0 = this.popNode()) && $0.is$Expression());
   var arguments = new NodeList.singleton$ctor(initializer);
   var name = (($0 = this.popNode()) && $0.is$Expression());
   this.pushNode(new SendSet(null, name, assignmentOperator, arguments));
 }
-BodyListener.prototype.endIfStatement = function(ifToken, elseToken) {
+NodeListener.prototype.endIfStatement = function(ifToken, elseToken) {
   var $0;
   var elsePart = (($0 = $notnull_bool((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));
 }
-BodyListener.prototype.endForStatement = function(beginToken, endToken) {
+NodeListener.prototype.endForStatement = function(beginToken, endToken) {
   var $0;
   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));
 }
-BodyListener.prototype.endBlock = function(count, beginToken, endToken) {
+NodeListener.prototype.endBlock = function(count, beginToken, endToken) {
   this.pushNode(new Block(this.makeNodeList(count, beginToken, endToken, null)));
 }
-BodyListener.prototype.endType = function(token) {
+NodeListener.prototype.endType = function(token) {
   var $0;
   this.pushNode(new TypeAnnotation((($0 = this.popNode()) && $0.is$Identifier())));
 }
-BodyListener.prototype.endThrowStatement = function(throwToken, endToken) {
+NodeListener.prototype.endThrowStatement = function(throwToken, endToken) {
   var $0;
   var expression = (($0 = this.popNode()) && $0.is$Expression());
   this.pushNode(new Throw(expression, throwToken, endToken));
 }
-BodyListener.prototype.endRethrowStatement = function(throwToken, endToken) {
+NodeListener.prototype.endRethrowStatement = function(throwToken, endToken) {
   this.pushNode(new Throw(null, throwToken, endToken));
 }
-BodyListener.prototype.handleNoType = function(token) {
-  this.pushNode(null);
-}
-BodyListener.prototype.makeNodeList = function(count, beginToken, endToken, delimiter) {
+NodeListener.prototype.makeNodeList = function(count, beginToken, endToken, delimiter) {
   var $0;
   var nodes = const$236/*const EmptyLink()*/;
   for (; $notnull_bool(count > 0); --count) {
     nodes = (($0 = nodes.prepend(this.popNode())) && $0.is$Link$Node());
   }
   var sourceDelimiter = (($0 = $notnull_bool((delimiter == null)) ? null : new StringWrapper(delimiter)) && $0.is$SourceString());
   return new NodeList(beginToken, nodes, endToken, sourceDelimiter);
 }
-BodyListener.prototype.log = function(message) {
+NodeListener.prototype.log = function(message) {
   this.logger.log(message);
 }
 // ********** Code for PartialFunctionElement **************
 function PartialFunctionElement(name, beginToken, endToken) {
   this.beginToken = beginToken;
   this.endToken = endToken;
   FunctionElement.call(this, name);
   // Initializers done
 }
 $inherits(PartialFunctionElement, FunctionElement);
 PartialFunctionElement.prototype.parseNode = function(canceler, logger) {
   var $this = this; // closure support
   var $0;
   if ($notnull_bool(this.node != null)) return this.node;
   this.node = (($0 = parse(canceler, logger, (function (p) {
     return p.parseFunction($this.beginToken);
   })
   )) && $0.is$FunctionExpression());
   return this.node;
 }
 // ********** Code for PartialClassElement **************
 function PartialClassElement(name, beginToken, endToken) {
   this.beginToken = beginToken;
   this.endToken = endToken;
   ClassElement.call(this, name);
   // Initializers done
 }
 $inherits(PartialClassElement, ClassElement);
 PartialClassElement.prototype.parseNode = function(canceler, logger) {
+  var $this = this; // closure support
+  var $0;
   if ($notnull_bool(this.node != null)) return this.node;
-  this.node = new ClassNode(this.name, this.beginToken, this.endToken);
+  this.node = (($0 = parse(canceler, logger, (function (p) {
+    return p.parseClass($this.beginToken);
+  })
+  )) && $0.is$ClassNode());
   return this.node;
 }
 // ********** Code for StringScanner **************
 function StringScanner(string) {
   this.string = string;
   ArrayBasedScanner$SourceString.call(this);
   // Initializers done
 }
 $inherits(StringScanner, ArrayBasedScanner$SourceString);
 StringScanner.prototype.nextByte = function() {
@@ skipping 37 matching lines @@
 }
 SubstringWrapper.prototype.get$stringValue = function() {
   return null;
 }
 // ********** Code for Token **************
 function Token(kind, charOffset) {
   this.kind = kind;
   this.charOffset = charOffset;
   // Initializers done
 }
+Token.prototype.is$Token = function(){return this;};
 Token.prototype.get$charOffset = function() { return this.charOffset; };
 Token.prototype.get$value = function() {
   return const$232/*const SourceString('EOF')*/;
 }
 Token.prototype.get$stringValue = function() {
   return 'EOF';
 }
 Token.prototype.toString = function() {
   return Strings.String$fromCharCodes$factory([this.kind]);
 }
@@ skipping 174 matching lines @@
   return true;
 }
 LeafKeywordState.prototype.next = function(c) {
   return null;
 }
 LeafKeywordState.prototype.toString = function() {
   return this.keyword.syntax;
 }
 // ********** Code for top level **************
 function parse(canceler, logger, doParse) {
-  var listener = new BodyListener(canceler, logger);
-  doParse(new BodyParser(listener));
+  var listener = new NodeListener(canceler, logger);
+  doParse(new Parser(listener));
   var node = listener.popNode();
   logger.log(("parsed: " + node + ""));
   return node;
 }
 //  ********** Library tree **************
 // ********** Code for Node **************
 function Node() {}
 Node.prototype.is$Node = function(){return this;};
 Node.prototype.hashCode = function() {
   return this._hashCode;
 }
 Node.prototype.toString = function() {
   return this.unparse();
 }
 Node.prototype.getObjectDescription = function() {
   return Object.prototype.toString.call(this);
 }
 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 + '>>');
   }
 }
 // ********** Code for ClassNode **************
-function ClassNode(name, beginToken, endToken) {
+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
 }
 $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;
 }
 // ********** Code for Expression **************
 function Expression() {}
 $inherits(Expression, Node);
 Expression.prototype.is$Expression = function(){return this;};
@@ skipping 3509 matching lines @@
       var interface_ = worklist.removeLast();
       this._maybeIsTest(type, interface_.get$genericType());
       if ($notnull_bool(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$lang_Type()));
         }
       }
       var $list = interface_.get$interfaces();
-      for (var $i = 0;$i < $list.length; $i++) {
-        var other = $list.$index($i);
+      for (var $i = interface_.get$interfaces().iterator(); $i.hasNext(); ) {
+        var other = $i.next();
         if ($notnull_bool(!$notnull_bool(seen.contains(other)))) {
           worklist.addLast(other);
           seen.add(other);
         }
       }
     }
   }
   type.get$factories().forEach(this.get$_writeMethod());
   var $list = this._orderValues(type.get$members());
   for (var $i = 0;$i < $list.length; $i++) {
@@ skipping 8181 matching lines @@
     seen.add(ancestor);
     ancestor = ancestor.get$parent();
   }
   return false;
 }
 DefinedType.prototype._cycleInInterfaceExtends = function() {
   var $this = this; // closure support
   var seen = new HashSetImplementation();
   seen.add(this);
   function _helper(ancestor) {
+    var $0;
     if ($notnull_bool(ancestor == null)) return false;
     if ($notnull_bool(ancestor === $this)) return true;
     if ($notnull_bool(seen.contains(ancestor))) {
       return false;
     }
     seen.add(ancestor);
-    if ($notnull_bool(ancestor.get$interfaces() != null)) {
+    if ($notnull_bool($ne(ancestor.get$interfaces(), null))) {
       var $list = ancestor.get$interfaces();
-      for (var $i = 0;$i < $list.length; $i++) {
-        var parent = $list.$index($i);
+      for (var $i = ancestor.get$interfaces().iterator(); $i.hasNext(); ) {
+        var parent = $i.next();
         if ($notnull_bool(_helper(parent))) return true;
       }
     }
     return false;
   }
   for (var i = 0;
    $notnull_bool(i < this.interfaces.length); i++) {
     if ($notnull_bool(_helper(this.interfaces.$index(i)))) return i;
   }
   return -1;
@@ skipping 1044 matching lines @@
 }
 World.prototype.runLeg = function() {
   var $this = this; // closure support
   if ($notnull_bool(!$notnull_bool(options.enableLeg))) return false;
   var res = $assert_bool(this.withTiming('try leg compile', (function () {
     return compile($this);
   })
   ));
   if ($notnull_bool(!$notnull_bool(res) && options.legOnly)) {
     this.fatal(("Leg could not compile " + options.dartScript + ""));
+    return true;
   }
   return res;
 }
 World.prototype.runCompilationPhases = function() {
   var $this = this; // closure support
   var lib = this.withTiming('first pass', (function () {
     return $this.processScript(options.dartScript);
   })
   );
   this.withTiming('resolve top level', (function () {
@@ skipping 20 matching lines @@
     }
     var codeWriter = new CodeWriter();
     $this.gen = new WorldGenerator(main, codeWriter);
     $this.gen.run();
     $this.jsBytesWritten = codeWriter.get$text().length;
   })
   );
 }
 World.prototype.getGeneratedCode = function() {
   if ($notnull_bool(this.legCode != null)) {
-    $assert(options.enableLeg, "options.enableLeg", "world.dart", 304, 14);
+    $assert(options.enableLeg, "options.enableLeg", "world.dart", 306, 14);
     return this.legCode;
   }
   else {
     return this.gen.writer.get$text();
   }
 }
 World.prototype.readFile = function(filename) {
   try {
     var sourceFile = this.reader.readFile(filename);
     this.dartBytesRead += sourceFile.get$text().length;
@@ skipping 676 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 RunEntry(function () {main();}, []);