Add implicit super() call

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 942 matching lines @@
 }
 ListIterator.prototype.hasNext$0 = function() {
   return this.hasNext();
 };
 ListIterator.prototype.next$0 = function() {
   return this.next();
 };
 // ********** Code for ImmutableList **************
 function ImmutableList(length) {
   this._length = length;
+  // Initializers done
   ListFactory$E.call(this, length);
-  // Initializers done
 }
 /** Implements extends for Dart classes on JavaScript prototypes. */
 function $inherits(child, parent) {
   if (child.prototype.__proto__) {
     child.prototype.__proto__ = parent.prototype;
   } else {
     function tmp() {};
     tmp.prototype = parent.prototype;
     child.prototype = new tmp();
     child.prototype.constructor = child;
@@ skipping 813 matching lines @@
 }
 DoubleLinkedQueueEntry$E.prototype.previousEntry = function() {
   return this._previous._asNonSentinelEntry();
 }
 // ********** Code for DoubleLinkedQueueEntry$KeyValuePair$K$V **************
 function DoubleLinkedQueueEntry$KeyValuePair$K$V() {}
 $inherits(DoubleLinkedQueueEntry$KeyValuePair$K$V, DoubleLinkedQueueEntry);
 DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.is$DoubleLinkedQueueEntry$KeyValuePair$K$V = function(){return this;};
 // ********** Code for _DoubleLinkedQueueEntrySentinel **************
 function _DoubleLinkedQueueEntrySentinel() {
+  // Initializers done
   DoubleLinkedQueueEntry$E.call(this, null);
-  // Initializers done
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel, DoubleLinkedQueueEntry$E);
 _DoubleLinkedQueueEntrySentinel.prototype.remove = function() {
   $throw(const$3/*const EmptyQueueException()*/);
 }
 _DoubleLinkedQueueEntrySentinel.prototype._asNonSentinelEntry = function() {
   return null;
 }
 _DoubleLinkedQueueEntrySentinel.prototype.get$element = function() {
   $throw(const$3/*const EmptyQueueException()*/);
 }
 // ********** Code for _DoubleLinkedQueueEntrySentinel$E **************
 function _DoubleLinkedQueueEntrySentinel$E() {
+  // Initializers done
   DoubleLinkedQueueEntry$E.call(this, null);
-  // Initializers done
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel$E, _DoubleLinkedQueueEntrySentinel);
 // ********** Code for _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V **************
 function _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V() {
+  // Initializers done
   DoubleLinkedQueueEntry$E.call(this, null);
-  // Initializers done
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V, _DoubleLinkedQueueEntrySentinel);
 // ********** Code for DoubleLinkedQueue **************
 function DoubleLinkedQueue() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$E();
 }
 DoubleLinkedQueue.prototype.is$Collection$E = function(){return this;};
 DoubleLinkedQueue.prototype.is$Collection$Object = function(){return this;};
@@ skipping 565 matching lines @@
 // ********** Code for LinkFactory **************
 function LinkFactory() {}
 LinkFactory.Link$factory = function(head, tail) {
   var $0;
   return new LinkEntry(head, (($0 = (tail == null) ? const$14/*const EmptyLink()*/ : tail) && $0.is$Link$T()));
 }
 // ********** Code for LinkFactory$Node **************
 function LinkFactory$Node() {}
 $inherits(LinkFactory$Node, LinkFactory);
 // ********** Code for AbstractLink **************
-function AbstractLink() {}
+function AbstractLink() {
+  // Initializers done
+}
 AbstractLink.prototype.is$Link = function(){return this;};
 AbstractLink.prototype.is$Link$Element = function(){return this;};
 AbstractLink.prototype.is$Link$Node = function(){return this;};
 AbstractLink.prototype.is$Link$T = function(){return this;};
 AbstractLink.prototype.is$Link$Token = function(){return this;};
 AbstractLink.prototype.is$Link$Type = function(){return this;};
 AbstractLink.prototype.is$Iterable = function(){return this;};
 AbstractLink.prototype.get$head = function() {
   $throw("bug");
 }
@@ skipping 31 matching lines @@
 AbstractLink.prototype.iterator$0 = function() {
   return this.iterator();
 };
 AbstractLink.prototype.printOn$1 = function($0) {
   return this.printOn(($0 && $0.is$StringBuffer()));
 };
 AbstractLink.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for AbstractLink$T **************
-function AbstractLink$T() {}
+function AbstractLink$T() {
+  // Initializers done
+}
 $inherits(AbstractLink$T, AbstractLink);
 AbstractLink$T.prototype.is$Link = function(){return this;};
 AbstractLink$T.prototype.is$Link$Element = function(){return this;};
 AbstractLink$T.prototype.is$Link$Node = function(){return this;};
 AbstractLink$T.prototype.is$Link$T = function(){return this;};
 AbstractLink$T.prototype.is$Link$Token = function(){return this;};
 AbstractLink$T.prototype.is$Link$Type = function(){return this;};
 AbstractLink$T.prototype.is$Iterable = function(){return this;};
 AbstractLink$T.prototype.iterator = function() {
   var $0;
   return (($0 = this.toList().iterator$0()) && $0.is$Iterator$T());
 }
 // ********** Code for LinkTail **************
 function LinkTail() {
   // Initializers done
+  AbstractLink$T.call(this);
 }
 $inherits(LinkTail, AbstractLink$T);
 LinkTail.prototype.is$Link = function(){return this;};
 LinkTail.prototype.is$Link$Element = function(){return this;};
 LinkTail.prototype.is$Link$Node = function(){return this;};
 LinkTail.prototype.is$Link$T = function(){return this;};
 LinkTail.prototype.is$Link$Token = function(){return this;};
 LinkTail.prototype.is$Link$Type = function(){return this;};
 LinkTail.prototype.is$Iterable = function(){return this;};
 LinkTail.prototype.get$head = function() {
@@ skipping 29 matching lines @@
 LinkTail$Type.prototype.is$Link$Node = function(){return this;};
 LinkTail$Type.prototype.is$Link$T = function(){return this;};
 LinkTail$Type.prototype.is$Link$Token = function(){return this;};
 LinkTail$Type.prototype.is$Link$Type = function(){return this;};
 LinkTail$Type.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkEntry **************
 function LinkEntry(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
+  AbstractLink$T.call(this);
 }
 $inherits(LinkEntry, AbstractLink$T);
 LinkEntry.prototype.get$head = function() { return this.head; };
 LinkEntry.prototype.get$tail = function() {
   return this.realTail;
 }
 LinkEntry.prototype.isEmpty = function() {
   return false;
 }
 LinkEntry.prototype.toList = function() {
   var $0;
   var list = new ListFactory();
   for (var link = this;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$T())) {
     list.addLast(link.get$head());
   }
   return list;
 }
 LinkEntry.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for LinkEntry$T **************
 function LinkEntry$T(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
+  AbstractLink$T.call(this);
 }
 $inherits(LinkEntry$T, LinkEntry);
 // ********** Code for LinkBuilderImplementation **************
 function LinkBuilderImplementation() {
   this.head = null
   this.lastLink = null
   // Initializers done
 }
 LinkBuilderImplementation.prototype.get$head = function() { return this.head; };
 LinkBuilderImplementation.prototype.set$head = function(value) { return this.head = value; };
@@ skipping 23 matching lines @@
 // ********** 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 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; };
 ArrayBasedScanner.prototype.get$byteOffset = function() { return this.byteOffset; };
 ArrayBasedScanner.prototype.set$byteOffset = function(value) { return this.byteOffset = value; };
@@ skipping 97 matching lines @@
   }
 }
 // ********** 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 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() {}
+function AbstractScanner() {
+  // Initializers done
+}
 AbstractScanner.prototype.tokenize = function() {
   var next = this.advance();
   while (next != -1) {
     next = this.bigSwitch(next);
   }
   this.appendEofToken();
   return this.firstToken();
 }
 AbstractScanner.prototype.bigSwitch = function(next) {
   this.beginToken();
@@ skipping 800 matching lines @@
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 AbstractScanner.prototype.appendByteStringToken$2 = AbstractScanner.prototype.appendByteStringToken;
 // ********** Code for AbstractScanner$S **************
-function AbstractScanner$S() {}
+function AbstractScanner$S() {
+  // Initializers done
+}
 $inherits(AbstractScanner$S, AbstractScanner);
 AbstractScanner$S.prototype.tokenize = function() {
   var next = this.advance();
   while (next != -1) {
     next = this.bigSwitch(next);
   }
   this.appendEofToken();
   return this.firstToken();
 }
 AbstractScanner$S.prototype.bigSwitch = function(next) {
@@ skipping 812 matching lines @@
   // Initializers done
 }
 MalformedInputException.prototype.toString = function() {
   return this.message.toString$0();
 }
 MalformedInputException.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for ScannerTask **************
 function ScannerTask(compiler) {
+  // Initializers done
   CompilerTask.call(this, compiler);
-  // Initializers done
 }
 $inherits(ScannerTask, CompilerTask);
 ScannerTask.prototype.get$name = function() {
   return 'Scanner';
 }
 ScannerTask.prototype.scan = function(script) {
   var $this = this; // closure support
   this.measure((function () {
     var $0;
     var elements = $this.scanElements(script.get$text());
@@ skipping 420 matching lines @@
   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$Token()));
 };
 // ********** Code for Parser **************
 function Parser(listener) {
+  // Initializers done
   PartialParser.call(this, listener);
-  // Initializers done
 }
 $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);
@@ skipping 545 matching lines @@
     token = this.parseExpression(token);
     this.listener.endThrowStatement$2(throwToken, token);
     return this.expectSemicolon(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);
-  // Initializers done
 }
 $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$Node());
 }
 // ********** Code for Listener **************
-function Listener() {}
+function Listener() {
+  // Initializers done
+}
 Listener.prototype.beginArguments = function(token) {
 
 }
 Listener.prototype.endArguments = function(count, beginToken, endToken) {
 
 }
 Listener.prototype.beginBlock = function(token) {
 
 }
 Listener.prototype.endBlock = function(count, beginToken, endToken) {
@@ skipping 424 matching lines @@
 ParserError.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for ElementListener **************
 function ElementListener(canceler) {
   this.previousIdentifier = null
   this.nodes = const$14/*const EmptyLink()*/
   this.topLevelElements = const$14/*const EmptyLink()*/
   this.canceler = canceler;
   // Initializers done
+  Listener.call(this);
 }
 $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();
   }
@@ skipping 113 matching lines @@
 };
 ElementListener.prototype.unexpected$1 = function($0) {
   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);
-  // Initializers done
   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$Identifier());
   this.pushNode(new ClassNode(name, supertype, interfaces, beginToken, extendsKeyword, endToken));
 }
@@ skipping 229 matching lines @@
 NodeListener.prototype.handleVarKeyword$1 = function($0) {
   return this.handleVarKeyword(($0 && $0.is$Token()));
 };
 NodeListener.prototype.handleVoidKeyword$1 = function($0) {
   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);
-  // Initializers done
 }
 $inherits(PartialFunctionElement, FunctionElement);
 PartialFunctionElement.prototype.parseNode = function(canceler, logger) {
   var $this = this; // closure support
   var $0;
   if (this.node != null) return this.node;
   this.node = (($0 = parse(canceler, logger, (function (p) {
     return p.parseFunction$1($this.beginToken);
   })
   )) && $0.is$FunctionExpression());
   return this.node;
 }
 // ********** Code for PartialClassElement **************
 function PartialClassElement(name, beginToken, endToken) {
   this.beginToken = beginToken;
   this.endToken = endToken;
+  // Initializers done
   ClassElement.call(this, name);
-  // Initializers done
 }
 $inherits(PartialClassElement, ClassElement);
 PartialClassElement.prototype.parseNode = function(canceler, logger) {
   var $this = this; // closure support
   var $0;
   if (this.node != null) return this.node;
   this.node = (($0 = parse(canceler, logger, (function (p) {
     return p.parseClass$1($this.beginToken);
   })
   )) && $0.is$ClassNode());
   return this.node;
 }
 // ********** Code for StringScanner **************
 function StringScanner(string) {
   this.string = string;
+  // Initializers done
   ArrayBasedScanner$SourceString.call(this);
-  // Initializers done
 }
 $inherits(StringScanner, ArrayBasedScanner$SourceString);
 StringScanner.prototype.nextByte = function() {
   return this.charAt(++this.byteOffset);
 }
 StringScanner.prototype.peek = function() {
   return this.charAt(this.byteOffset + 1);
 }
 StringScanner.prototype.charAt = function(index) {
   return (this.string.length > $assert_num(index)) ? this.string.charCodeAt($assert_num(index)) : -1;
@@ skipping 62 matching lines @@
 }
 Token.prototype.next$0 = function() {
   return this.next();
 };
 Token.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for KeywordToken **************
 function KeywordToken(value, charOffset) {
   this.value = value;
+  // Initializers done
   Token.call(this, 107/*null.KEYWORD_TOKEN*/, charOffset);
-  // Initializers done
 }
 $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);
-  // Initializers done
 }
 StringToken.fromSource$ctor = function(kind, value, charOffset) {
   this.value = value;
+  // Initializers done
   Token.call(this, kind, charOffset);
-  // Initializers done
 }
 StringToken.fromSource$ctor.prototype = StringToken.prototype;
 $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();
 }
@@ skipping 25 matching lines @@
   return this.hashCode();
 };
 StringWrapper.prototype.printOn$1 = function($0) {
   return this.printOn(($0 && $0.is$StringBuffer()));
 };
 StringWrapper.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for BeginGroupToken **************
 function BeginGroupToken(kind, value, charOffset) {
+  // Initializers done
   StringToken.call(this, kind, value, charOffset);
-  // Initializers done
 }
 $inherits(BeginGroupToken, StringToken);
 BeginGroupToken.prototype.is$BeginGroupToken = function(){return this;};
 // ********** Code for Keyword **************
 function Keyword(syntax, isPseudo) {
   this.syntax = syntax;
   this.isPseudo = isPseudo;
   // Initializers done
 }
 Keyword.prototype.is$SourceString = function(){return this;};
@@ skipping 29 matching lines @@
 Keyword.prototype.hashCode$0 = function() {
   return this.hashCode();
 };
 Keyword.prototype.printOn$1 = function($0) {
   return this.printOn(($0 && $0.is$StringBuffer()));
 };
 Keyword.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for KeywordState **************
-function KeywordState() {}
+function KeywordState() {
+  // Initializers done
+}
 KeywordState.prototype.is$KeywordState = function(){return this;};
 KeywordState.get$KEYWORD_STATE = function() {
   if (KeywordState._KEYWORD_STATE == null) {
     var strings = new ListFactory(const$232/*Keyword.values*/.get$length());
     for (var i = 0;
      i < const$232/*Keyword.values*/.get$length(); i++) {
       strings.$setindex(i, const$232/*Keyword.values*/[i].syntax);
     }
     strings.sort((function (a, b) {
       return a.compareTo$1(b);
@@ skipping 27 matching lines @@
   else {
     $assert(length == 1, "length == 1", "keyword.dart", 183, 14);
     return new LeafKeywordState($assert_String(strings.$index(offset)));
   }
   return new ArrayKeywordState(result);
 }
 // ********** Code for ArrayKeywordState **************
 function ArrayKeywordState(table) {
   this.table = table;
   // Initializers done
+  KeywordState.call(this);
 }
 $inherits(ArrayKeywordState, KeywordState);
 ArrayKeywordState.prototype.isLeaf = function() {
   return false;
 }
 ArrayKeywordState.prototype.next = function(c) {
   var $0;
   return (($0 = this.table.$index(c - 97/*null.$a*/)) && $0.is$KeywordState());
 }
 ArrayKeywordState.prototype.get$keyword = function() {
@@ skipping 12 matching lines @@
   sb.add("]");
   return sb.toString();
 }
 ArrayKeywordState.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for LeafKeywordState **************
 function LeafKeywordState(syntax) {
   this.keyword = Keyword.get$keywords().$index(syntax);
   // Initializers done
+  KeywordState.call(this);
 }
 $inherits(LeafKeywordState, KeywordState);
 LeafKeywordState.prototype.get$keyword = function() { return this.keyword; };
 LeafKeywordState.prototype.set$keyword = function(value) { return this.keyword = value; };
 LeafKeywordState.prototype.isLeaf = function() {
   return true;
 }
 LeafKeywordState.prototype.next = function(c) {
   return null;
 }
 LeafKeywordState.prototype.toString = function() {
   return this.keyword.syntax;
 }
 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 Parser(listener));
   var node = listener.popNode();
   logger.log(("parsed: " + node + ""));
   return node;
 }
 //  ********** Library tree **************
 // ********** Code for Node **************
-function Node() {}
+function Node() {
+  this._hashCode = (Math.random() * 0xFFFFFFFF).toInt();
+  // Initializers done
+}
 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);
 }
@@ skipping 23 matching lines @@
 };
 // ********** 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
+  Node.call(this);
 }
 $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';
@@ skipping 10 matching lines @@
 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 Expression **************
-function Expression() {}
+function Expression() {
+  // Initializers done
+  Node.call(this);
+}
 $inherits(Expression, Node);
 Expression.prototype.is$Expression = function(){return this;};
 // ********** Code for Statement **************
-function Statement() {}
+function Statement() {
+  // Initializers done
+  Node.call(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
+  Expression.call(this);
 }
 Send.postfix$ctor = function(receiver, selector) {
   this.receiver = receiver;
   this.selector = selector;
   this.argumentsNode = const$249/*const Postfix()*/;
   // Initializers done
+  Expression.call(this);
 }
 Send.postfix$ctor.prototype = Send.prototype;
 Send.prefix$ctor = function(receiver, selector) {
   this.receiver = receiver;
   this.selector = selector;
   this.argumentsNode = const$248/*const Prefix()*/;
   // Initializers done
+  Expression.call(this);
 }
 Send.prefix$ctor.prototype = Send.prototype;
 $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);
 }
@@ skipping 26 matching lines @@
   return this.accept(($0 && $0.is$Visitor()));
 };
 Send.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 Send.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for Postfix **************
 function Postfix() {
+  // Initializers done
   NodeList.call(this);
-  // Initializers done
 }
 $inherits(Postfix, NodeList);
 // ********** Code for Prefix **************
 function Prefix() {
+  // Initializers done
   NodeList.call(this);
-  // Initializers done
 }
 $inherits(Prefix, NodeList);
 // ********** Code for SendSet **************
 function SendSet(receiver, selector, assignmentOperator, argumentsNode) {
   this.assignmentOperator = assignmentOperator;
+  // Initializers done
   Send.call(this, receiver, selector, argumentsNode);
-  // Initializers done
 }
 $inherits(SendSet, Send);
 SendSet.prototype.is$SendSet = function(){return this;};
 SendSet.prototype.accept = function(visitor) {
   return visitor.visitSendSet(this);
 }
 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
+  Node.call(this);
 }
 NodeList.singleton$ctor = function(node) {
+  // Initializers done
   NodeList.call(this, null, LinkFactory.Link$factory(node));
-  // Initializers done
 }
 NodeList.singleton$ctor.prototype = NodeList.prototype;
 $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;
@@ skipping 27 matching lines @@
 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
+  Statement.call(this);
 }
 $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
+  Statement.call(this);
 }
 $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;
@@ skipping 12 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
+  Statement.call(this);
 }
 $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
+  Expression.call(this);
 }
 $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
+  Expression.call(this);
 }
 $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
+  Expression.call(this);
 }
 $inherits(Literal$SourceString, Literal);
 // ********** Code for Literal$bool **************
 function Literal$bool(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
+  Expression.call(this);
 }
 $inherits(Literal$bool, Literal);
 // ********** Code for Literal$double **************
 function Literal$double(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
+  Expression.call(this);
 }
 $inherits(Literal$double, Literal);
 // ********** Code for Literal$int **************
 function Literal$int(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
+  Expression.call(this);
 }
 $inherits(Literal$int, Literal);
 // ********** Code for LiteralInt **************
 function LiteralInt(token, handler) {
+  // Initializers done
   Literal$int.call(this, token, handler);
-  // Initializers done
 }
 $inherits(LiteralInt, Literal$int);
 LiteralInt.prototype.get$value = function() {
   try {
     return Math.parseInt(this.token.get$value().toString$0());
   } catch (ex) {
     ex = $toDartException(ex);
     if (!(ex instanceof BadNumberFormatException)) throw ex;
     (this.handler)(this.token, ex);
   }
 }
 LiteralInt.prototype.accept = function(visitor) {
   return visitor.visitLiteralInt(this);
 }
 LiteralInt.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 // ********** Code for LiteralDouble **************
 function LiteralDouble(token, handler) {
+  // Initializers done
   Literal$double.call(this, token, handler);
-  // Initializers done
 }
 $inherits(LiteralDouble, Literal$double);
 LiteralDouble.prototype.get$value = function() {
   try {
     return Math.parseDouble(this.token.get$value().toString$0());
   } catch (ex) {
     ex = $toDartException(ex);
     if (!(ex instanceof BadNumberFormatException)) throw ex;
     (this.handler)(this.token, ex);
   }
 }
 LiteralDouble.prototype.accept = function(visitor) {
   return visitor.visitLiteralDouble(this);
 }
 LiteralDouble.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 // ********** Code for LiteralBool **************
 function LiteralBool(token, handler) {
+  // Initializers done
   Literal$bool.call(this, token, handler);
-  // Initializers done
 }
 $inherits(LiteralBool, Literal$bool);
 LiteralBool.prototype.get$value = function() {
   switch (this.token.get$value()) {
     case const$188/*Keyword.TRUE*/:
 
       return true;
 
     case const$160/*Keyword.FALSE*/:
 
       return false;
 
     default:
 
       (this.handler)(this.token, ("not a bool " + this.token.get$value() + ""));
 
   }
 }
 LiteralBool.prototype.accept = function(visitor) {
   return visitor.visitLiteralBool(this);
 }
 LiteralBool.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 // ********** Code for LiteralString **************
 function LiteralString(token) {
+  // Initializers done
   Literal$SourceString.call(this, token, to$call$2(null));
-  // Initializers done
 }
 $inherits(LiteralString, Literal$SourceString);
 LiteralString.prototype.is$LiteralString = function(){return this;};
 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 Identifier **************
 function Identifier(token) {
   this.token = token;
   // Initializers done
+  Expression.call(this);
 }
 $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());
 }
 Identifier.prototype.accept = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 Identifier.prototype.getBeginToken = function() {
   return this.token;
 }
 Identifier.prototype.getEndToken = function() {
   return this.token;
 }
 Identifier.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 Identifier.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 Identifier.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for Operator **************
 function Operator(token) {
+  // Initializers done
   Identifier.call(this, token);
-  // Initializers done
 }
 $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
+  Statement.call(this);
 }
 $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 ExpressionStatement **************
 function ExpressionStatement(expression, endToken) {
   this.expression = expression;
   this.endToken = endToken;
   // Initializers done
+  Statement.call(this);
 }
 $inherits(ExpressionStatement, Statement);
 ExpressionStatement.prototype.is$ExpressionStatement = function(){return this;};
 ExpressionStatement.prototype.accept = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
 ExpressionStatement.prototype.getBeginToken = function() {
   var $0;
   return (($0 = this.expression.getBeginToken()) && $0.is$Token());
 }
 ExpressionStatement.prototype.getEndToken = function() {
   return this.endToken;
 }
 ExpressionStatement.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 ExpressionStatement.prototype.getBeginToken$0 = function() {
   return this.getBeginToken();
 };
 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
+  Statement.call(this);
 }
 $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
+  Node.call(this);
 }
 $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$Token());
@@ skipping 11 matching lines @@
 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
+  Statement.call(this);
 }
 $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);
 }
@@ skipping 188 matching lines @@
 Element.prototype.computeType$2 = function($0, $1) {
   return this.computeType(($0 && $0.is$Compiler()), ($1 && $1.is$Types()));
 };
 Element.prototype.hashCode$0 = function() {
   return this.hashCode();
 };
 // ********** Code for VariableElement **************
 function VariableElement(node, typeAnnotation, name, enclosingElement) {
   this.node = node;
   this.typeAnnotation = typeAnnotation;
+  // Initializers done
   Element.call(this, name, const$266, enclosingElement);
-  // Initializers done
 }
 $inherits(VariableElement, Element);
 VariableElement.prototype.get$type = function() { return this.type; };
 VariableElement.prototype.set$type = function(value) { return this.type = value; };
 VariableElement.prototype.parseNode = function(canceler, logger) {
   return this.node;
 }
 VariableElement.prototype.computeType = function(compiler, types) {
   return getType(this.typeAnnotation, types);
 }
 VariableElement.prototype.computeType$2 = function($0, $1) {
   return this.computeType(($0 && $0.is$Compiler()), ($1 && $1.is$Types()));
 };
 // ********** Code for ForeignElement **************
 function ForeignElement(name) {
+  // Initializers done
   Element.call(this, name, const$242, null);
-  // Initializers done
 }
 $inherits(ForeignElement, Element);
 ForeignElement.prototype.computeType = function(compiler, types) {
   return types.dynamicType;
 }
 ForeignElement.prototype.computeType$2 = function($0, $1) {
   return this.computeType(($0 && $0.is$Compiler()), ($1 && $1.is$Types()));
 };
 // ********** Code for FunctionElement **************
 function FunctionElement(name) {
+  // Initializers done
   Element.call(this, name, const$239, null);
-  // Initializers done
 }
 $inherits(FunctionElement, Element);
 FunctionElement.prototype.get$type = function() { return this.type; };
 FunctionElement.prototype.set$type = function(value) { return this.type = value; };
 FunctionElement.prototype.computeType = function(compiler, types) {
   var $0;
   if (this.type != null) return (($0 = this.type) && $0.is$FunctionType());
   var node = (($0 = this.parseNode(compiler, compiler)) && $0.is$FunctionExpression());
   var returnType = getType(node.returnType, types);
   if (returnType == null) compiler.cancel(('unknown type ' + returnType + ''));
   var parameterTypes = new LinkBuilderImplementation();
   for (var link = node.parameters.nodes;
    !$notnull_bool(link.isEmpty$0()); link = link.get$tail()) {
     var parameter = (($0 = link.get$head()) && $0.is$VariableDefinitions());
     parameterTypes.addLast(getType(parameter.type, types));
   }
   this.type = new FunctionType(returnType, (($0 = parameterTypes.toLink()) && $0.is$Link$Type()));
   return (($0 = this.type) && $0.is$FunctionType());
 }
 FunctionElement.prototype.computeType$2 = FunctionElement.prototype.computeType;
 // ********** Code for ClassElement **************
 function ClassElement(name) {
   this.interfaces = const$14/*const EmptyLink()*/
   this.isResolved = false
+  // Initializers done
   Element.call(this, name, const$237, null);
-  // Initializers done
 }
 $inherits(ClassElement, Element);
 ClassElement.prototype.is$ClassElement = function(){return this;};
 ClassElement.prototype.get$type = function() { return this.type; };
 ClassElement.prototype.set$type = function(value) { return this.type = value; };
 ClassElement.prototype.get$interfaces = function() { return this.interfaces; };
 ClassElement.prototype.set$interfaces = function(value) { return this.interfaces = value; };
 ClassElement.prototype.computeType = function(compiler, types) {
   if (this.type == null) {
     this.type = new SimpleType(this.name, this);
@@ skipping 13 matching lines @@
 function getType(annotation, types) {
   var $0;
   if (annotation == null || annotation.typeName == null) {
     return (($0 = types.dynamicType) && $0.is$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);
-  // Initializers done
 }
 $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;
@@ skipping 359 matching lines @@
   }
 }
 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$Node()));
 };
 // ********** Code for SsaCodeGeneratorTask **************
 function SsaCodeGeneratorTask(compiler) {
+  // Initializers done
   CompilerTask.call(this, compiler);
-  // Initializers done
 }
 $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());
@@ skipping 332 matching lines @@
     for (var i = dominated.length - 1;
      i >= 0; i--) {
       visitBasicBlockAndSuccessors((($0 = dominated.$index(i)) && $0.is$HBasicBlock()));
     }
     $this.visitBasicBlock(block);
   }
   visitBasicBlockAndSuccessors(graph.entry);
 }
 // ********** Code for HInstructionVisitor **************
 function HInstructionVisitor() {
+  // Initializers done
   HGraphVisitor.call(this);
-  // Initializers done
 }
 $inherits(HInstructionVisitor, HGraphVisitor);
 HInstructionVisitor.prototype.visitBasicBlock = function(node) {
   this.currentBlock = node;
   var instruction = node.first;
   while (instruction != null) {
     this.visitInstruction(instruction);
     instruction = instruction.next;
   }
 }
@@ skipping 53 matching lines @@
   }
   handleDominatorTree(this.entry, 0);
 }
 HGraph.prototype.isValid = function() {
   var validator = new HValidator();
   validator.visitGraph(this);
   return validator.isValid;
 }
 // ********** Code for HBaseVisitor **************
 function HBaseVisitor() {
+  // Initializers done
   HGraphVisitor.call(this);
-  // Initializers done
 }
 $inherits(HBaseVisitor, HGraphVisitor);
 HBaseVisitor.prototype.is$HVisitor = function(){return this;};
 HBaseVisitor.prototype.visitBasicBlock = function(node) {
   this.currentBlock = node;
   var instruction = node.first;
   while (instruction != null) {
     instruction.accept(this);
     instruction = instruction.next;
   }
@@ skipping 55 matching lines @@
 HBaseVisitor.prototype.visitSubtract = function(node) {
   return this.visitArithmetic(node);
 }
 HBaseVisitor.prototype.visitThrow = function(node) {
   return this.visitControlFlow(node);
 }
 HBaseVisitor.prototype.visitTruncatingDivide = function(node) {
   return this.visitArithmetic(node);
 }
 // ********** Code for HInstructionList **************
-function HInstructionList() {}
+function HInstructionList() {
+  this.first = null
+  this.last = null
+  // Initializers done
+}
 HInstructionList.prototype.isEmpty = function() {
   return this.first == null;
 }
 HInstructionList.prototype.addAfter = function(cursor, instruction) {
   if (cursor == null) {
     $assert(this.isEmpty(), "isEmpty()", "nodes.dart", 185, 14);
     this.first = this.last = instruction;
   }
   else if (cursor === this.last) {
     this.last.next = instruction;
@@ skipping 41 matching lines @@
   return this.isEmpty();
 };
 HInstructionList.prototype.last$0 = function() {
   return this.last();
 };
 // ********** Code for HBasicBlock **************
 function HBasicBlock() {
   this.status = 0/*HBasicBlock.STATUS_NEW*/
   this.isLoopHeader = false
   this.dominator = null
+  // Initializers done
   HBasicBlock.withId$ctor.call(this, null);
-  // Initializers done
 }
 HBasicBlock.withId$ctor = function(id) {
   this.status = 0/*HBasicBlock.STATUS_NEW*/
   this.isLoopHeader = false
   this.dominator = null
   this.id = id;
   this.predecessors = [];
   this.successors = const$13/*const []*/;
   this.dominatedBlocks = [];
   // Initializers done
+  HInstructionList.call(this);
 }
 HBasicBlock.withId$ctor.prototype = HBasicBlock.prototype;
 $inherits(HBasicBlock, HInstructionList);
 HBasicBlock.prototype.is$HBasicBlock = function(){return this;};
 HBasicBlock.prototype.isNew = function() {
   return this.status == 0/*HBasicBlock.STATUS_NEW*/;
 }
 HBasicBlock.prototype.isOpen = function() {
   return this.status == 1/*HBasicBlock.STATUS_OPEN*/;
 }
@@ skipping 231 matching lines @@
   return this.isLiteralString();
 };
 HInstruction.prototype.next$0 = function() {
   return this.next();
 };
 HInstruction.prototype.setGenerateAtUseSite$0 = function() {
   return this.setGenerateAtUseSite();
 };
 // ********** Code for HConditionalBranch **************
 function HConditionalBranch(inputs) {
+  // Initializers done
   HControlFlow.call(this, inputs);
-  // Initializers done
 }
 $inherits(HConditionalBranch, HControlFlow);
 HConditionalBranch.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HControlFlow **************
 function HControlFlow(inputs) {
+  // Initializers done
   HInstruction.call(this, inputs);
-  // Initializers done
 }
 $inherits(HControlFlow, HInstruction);
 HControlFlow.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HInvoke **************
 function HInvoke(element, inputs) {
   this.element = element;
+  // Initializers done
   HInstruction.call(this, inputs);
-  // Initializers done
 }
 $inherits(HInvoke, HInstruction);
 HInvoke.prototype.get$element = function() { return this.element; };
 HInvoke.prototype.toString = function() {
   return ('invoke: ' + this.element.name + '');
 }
 HInvoke.prototype.accept = function(visitor) {
   return visitor.visitInvoke(this);
 }
 HInvoke.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HInvoke.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HInvokeForeign **************
 function HInvokeForeign(element, inputs, code) {
   this.code = code;
+  // Initializers done
   HInvoke.call(this, element, inputs);
-  // Initializers done
 }
 $inherits(HInvokeForeign, HInvoke);
 HInvokeForeign.prototype.accept = function(visitor) {
   return visitor.visitInvokeForeign(this);
 }
 HInvokeForeign.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 // ********** Code for HArithmetic **************
 function HArithmetic(element, inputs) {
+  // Initializers done
   HInvoke.call(this, element, inputs);
-  // Initializers done
 }
 $inherits(HArithmetic, HInvoke);
 HArithmetic.prototype.prepareGvn = function() {
   if (!(this.inputs.$index(0) instanceof HLiteral)) return;
   this.clearAllSideEffects();
   this.setUseGvn();
 }
 // ********** Code for HAdd **************
 function HAdd(element, inputs) {
+  // Initializers done
   HArithmetic.call(this, element, inputs);
-  // Initializers done
 }
 $inherits(HAdd, HArithmetic);
 HAdd.prototype.prepareGvn = function() {
   if (!$notnull_bool(this.inputs.$index(0).isLiteralNumber$0())) return;
   this.clearAllSideEffects();
   this.setUseGvn();
 }
 HAdd.prototype.accept = function(visitor) {
   return visitor.visitAdd(this);
 }
 HAdd.prototype.evaluate = function(a, b) {
   return a + b;
 }
 HAdd.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 // ********** Code for HDivide **************
 function HDivide(element, inputs) {
+  // Initializers done
   HArithmetic.call(this, element, inputs);
-  // Initializers done
 }
 $inherits(HDivide, HArithmetic);
 HDivide.prototype.accept = function(visitor) {
   return visitor.visitDivide(this);
 }
 HDivide.prototype.evaluate = function(a, b) {
   return a / b;
 }
 HDivide.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 // ********** Code for HMultiply **************
 function HMultiply(element, inputs) {
+  // Initializers done
   HArithmetic.call(this, element, inputs);
-  // Initializers done
 }
 $inherits(HMultiply, HArithmetic);
 HMultiply.prototype.accept = function(visitor) {
   return visitor.visitMultiply(this);
 }
 HMultiply.prototype.evaluate = function(a, b) {
   return a * b;
 }
 HMultiply.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 // ********** Code for HSubtract **************
 function HSubtract(element, inputs) {
+  // Initializers done
   HArithmetic.call(this, element, inputs);
-  // Initializers done
 }
 $inherits(HSubtract, HArithmetic);
 HSubtract.prototype.accept = function(visitor) {
   return visitor.visitSubtract(this);
 }
 HSubtract.prototype.evaluate = function(a, b) {
   return a - b;
 }
 HSubtract.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 // ********** Code for HTruncatingDivide **************
 function HTruncatingDivide(element, inputs) {
+  // Initializers done
   HArithmetic.call(this, element, inputs);
-  // Initializers done
 }
 $inherits(HTruncatingDivide, HArithmetic);
 HTruncatingDivide.prototype.accept = function(visitor) {
   return visitor.visitTruncatingDivide(this);
 }
 HTruncatingDivide.prototype.evaluate = function(a, b) {
   return $truncdiv(a, b);
 }
 HTruncatingDivide.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 // ********** Code for HEquals **************
 function HEquals(element, inputs) {
+  // Initializers done
   HInvoke.call(this, element, inputs);
-  // Initializers done
 }
 $inherits(HEquals, HInvoke);
 HEquals.prototype.prepareGvn = function() {
   if (!(this.inputs.$index(0) instanceof HLiteral)) return;
   this.clearAllSideEffects();
   this.setUseGvn();
 }
 HEquals.prototype.accept = function(visitor) {
   return visitor.visitEquals(this);
 }
 HEquals.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 // ********** Code for HExit **************
 function HExit() {
+  // Initializers done
   HControlFlow.call(this, const$13/*const []*/);
-  // Initializers done
 }
 $inherits(HExit, HControlFlow);
 HExit.prototype.toString = function() {
   return 'exit';
 }
 HExit.prototype.accept = function(visitor) {
   return visitor.visitExit(this);
 }
 HExit.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HExit.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HGoto **************
 function HGoto() {
+  // Initializers done
   HControlFlow.call(this, const$13/*const []*/);
-  // Initializers done
 }
 $inherits(HGoto, HControlFlow);
 HGoto.prototype.toString = function() {
   return 'goto';
 }
 HGoto.prototype.accept = function(visitor) {
   return visitor.visitGoto(this);
 }
 HGoto.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HGoto.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HIf **************
 function HIf(condition, hasElse) {
   this.hasElse = hasElse;
+  // Initializers done
   HConditionalBranch.call(this, [condition]);
-  // Initializers done
 }
 $inherits(HIf, HConditionalBranch);
 HIf.prototype.toString = function() {
   return 'if';
 }
 HIf.prototype.accept = function(visitor) {
   return visitor.visitIf(this);
 }
 HIf.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HIf.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HLoopBranch **************
 function HLoopBranch(condition) {
+  // Initializers done
   HConditionalBranch.call(this, [condition]);
-  // Initializers done
 }
 $inherits(HLoopBranch, HConditionalBranch);
 HLoopBranch.prototype.toString = function() {
   return 'loop-branch';
 }
 HLoopBranch.prototype.accept = function(visitor) {
   return visitor.visitLoopBranch(this);
 }
 HLoopBranch.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HLoopBranch.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HLiteral **************
 function HLiteral(value) {
   this.value = value;
+  // Initializers done
   HInstruction.call(this, []);
-  // Initializers done
 }
 $inherits(HLiteral, HInstruction);
 HLiteral.prototype.is$HLiteral = function(){return this;};
 HLiteral.prototype.get$value = function() { return this.value; };
 HLiteral.prototype.prepareGvn = function() {
   this.clearAllSideEffects();
   this.setUseGvn();
 }
 HLiteral.prototype.toString = function() {
   return ('literal: ' + this.value + '');
@@ skipping 16 matching lines @@
 };
 HLiteral.prototype.isLiteralString$0 = function() {
   return this.isLiteralString();
 };
 HLiteral.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HParameter **************
 function HParameter(parameterIndex) {
   this.parameterIndex = parameterIndex;
+  // Initializers done
   HInstruction.call(this, []);
-  // Initializers done
 }
 $inherits(HParameter, HInstruction);
 HParameter.prototype.prepareGvn = function() {
   this.clearAllSideEffects();
 }
 HParameter.prototype.toString = function() {
   return ('parameter ' + this.parameterIndex + '');
 }
 HParameter.prototype.accept = function(visitor) {
   return visitor.visitParameter(this);
 }
 HParameter.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HParameter.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HPhi **************
 function HPhi() {}
 HPhi.singleInput$ctor = function(element, input) {
   this.element = element;
+  // Initializers done
   HInstruction.call(this, [input]);
-  // Initializers done
 }
 HPhi.singleInput$ctor.prototype = HPhi.prototype;
 HPhi.manyInputs$ctor = function(element, inputs) {
   this.element = element;
+  // Initializers done
   HInstruction.call(this, inputs);
-  // Initializers done
 }
 HPhi.manyInputs$ctor.prototype = HPhi.prototype;
 $inherits(HPhi, HInstruction);
 HPhi.prototype.is$HPhi = function(){return this;};
 HPhi.prototype.get$element = function() { return this.element; };
 HPhi.prototype.addInput = function(input) {
   $assert(this.isInBasicBlock(), "isInBasicBlock()", "nodes.dart", 704, 12);
   this.inputs.add(input);
   input.get$usedBy().add(this);
 }
 HPhi.prototype.toString = function() {
   return 'phi';
 }
 HPhi.prototype.accept = function(visitor) {
   return visitor.visitPhi(this);
 }
 HPhi.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HPhi.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HReturn **************
 function HReturn(value) {
+  // Initializers done
   HControlFlow.call(this, [value]);
-  // Initializers done
 }
 $inherits(HReturn, HControlFlow);
 HReturn.prototype.toString = function() {
   return 'return';
 }
 HReturn.prototype.accept = function(visitor) {
   return visitor.visitReturn(this);
 }
 HReturn.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HReturn.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HThrow **************
 function HThrow(value) {
+  // Initializers done
   HControlFlow.call(this, [value]);
-  // Initializers done
 }
 $inherits(HThrow, HControlFlow);
 HThrow.prototype.toString = function() {
   return 'throw';
 }
 HThrow.prototype.accept = function(visitor) {
   return visitor.visitThrow(this);
 }
 HThrow.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HThrow.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for SsaOptimizerTask **************
 function SsaOptimizerTask(compiler) {
+  // Initializers done
   CompilerTask.call(this, compiler);
-  // Initializers done
 }
 $inherits(SsaOptimizerTask, CompilerTask);
 SsaOptimizerTask.prototype.get$name = function() {
   return 'SSA optimizer';
 }
 SsaOptimizerTask.prototype.optimize = function(graph) {
   this.measure((function () {
     new SsaConstantFolder().visitGraph(graph);
     new SsaDeadCodeEliminator().visitGraph(graph);
     new SsaInstructionMerger().visitGraph(graph);
   })
   );
 }
 // ********** Code for SsaConstantFolder **************
 function SsaConstantFolder() {
+  // Initializers done
   HBaseVisitor.call(this);
-  // Initializers done
 }
 $inherits(SsaConstantFolder, HBaseVisitor);
 SsaConstantFolder.prototype.visitGraph = function(graph) {
   this.visitDominatorTree(graph);
 }
 SsaConstantFolder.prototype.visitBasicBlock = function(block) {
   var instruction = block.first;
   while (instruction != null) {
     var replacement = instruction.accept(this);
     if (replacement !== instruction) {
@@ skipping 39 matching lines @@
   var $0;
   if ($notnull_bool(node.inputs.$index(0).isLiteralString$0())) {
     var op1 = (($0 = node.inputs.$index(0)) && $0.is$HLiteral());
     var op2 = (($0 = node.inputs.$index(1)) && $0.is$HLiteral());
     return new HLiteral(new StringWrapper(("" + op1.value + " + " + op2.value + "")));
   }
   return this.visitArithmetic(node);
 }
 // ********** Code for SsaDeadCodeEliminator **************
 function SsaDeadCodeEliminator() {
+  // Initializers done
   HGraphVisitor.call(this);
-  // Initializers done
 }
 $inherits(SsaDeadCodeEliminator, HGraphVisitor);
 SsaDeadCodeEliminator.isDeadCode = function(instruction) {
   return !$notnull_bool(instruction.hasSideEffects()) && instruction.get$usedBy().isEmpty();
 }
 SsaDeadCodeEliminator.prototype.visitGraph = function(graph) {
   this.visitPostDominatorTree(graph);
 }
 SsaDeadCodeEliminator.prototype.visitBasicBlock = function(block) {
   var instruction = block.last;
   while (instruction != null) {
     var previous = instruction.previous;
     if ($notnull_bool(SsaDeadCodeEliminator.isDeadCode(instruction))) block.remove(instruction);
     instruction = (previous && previous.is$HInstruction());
   }
 }
 // ********** Code for SsaInstructionMerger **************
 function SsaInstructionMerger() {
+  // Initializers done
   HInstructionVisitor.call(this);
-  // Initializers done
 }
 $inherits(SsaInstructionMerger, HInstructionVisitor);
 SsaInstructionMerger.prototype.visitGraph = function(graph) {
   this.visitDominatorTree(graph);
 }
 SsaInstructionMerger.prototype.visitInstruction = function(node) {
   var inputs = node.inputs;
   var previousUnused = node.previous;
   for (var i = inputs.length - 1;
    i >= 0; i--) {
     if (previousUnused == null) return;
     if ((previousUnused instanceof HPhi)) return;
     if (inputs.$index(i).get$usedBy().length != 1) return;
     if (inputs.$index(i) !== previousUnused) return;
     inputs.$index(i).setGenerateAtUseSite$0();
     previousUnused = previousUnused.previous;
   }
 }
 // ********** Code for HTracer **************
 function HTracer() {}
 HTracer._internal$ctor = function() {
   this.indent = 0
   this.output = new StringBufferImpl("");
   // Initializers done
+  HGraphVisitor.call(this);
 }
 HTracer._internal$ctor.prototype = HTracer.prototype;
 $inherits(HTracer, HGraphVisitor);
 HTracer.HTracer$singleton$factory = function() {
   if (HTracer._singleton == null) HTracer._singleton = new HTracer._internal$ctor();
   return HTracer._singleton;
 }
 HTracer.prototype.traceCompilation = function(methodName) {
   var $this = this; // closure support
   this.tag("compilation", (function () {
@@ skipping 212 matching lines @@
 }
 HInstructionStringifier.prototype.visitTruncatingDivide = function(node) {
   return this.visitInvoke(node);
 }
 HInstructionStringifier.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$HInstruction()));
 };
 // ********** Code for HValidator **************
 function HValidator() {
   this.isValid = true
+  // Initializers done
   HInstructionVisitor.call(this);
-  // Initializers done
 }
 $inherits(HValidator, HInstructionVisitor);
 HValidator.prototype.visitGraph = function(graph) {
   this.graph = graph;
   this.visitDominatorTree(graph);
 }
 HValidator.prototype.markInvalid = function(reason) {
   print(reason);
   this.isValid = false;
 }
@@ skipping 99 matching lines @@
     })
     );
   }
   this.isValid = $notnull_bool(this.isValid) && $notnull_bool(hasCorrectInputs(instruction)) && $notnull_bool(hasCorrectUses(instruction));
 }
 // ********** Code for top level **************
 //  ********** Library leg **************
 // ********** Code for WorldCompiler **************
 function WorldCompiler(world, script) {
   this.world = world;
+  // Initializers done
   Compiler.call(this, script);
-  // Initializers done
 }
 $inherits(WorldCompiler, Compiler);
 WorldCompiler.prototype.log = function(message) {
   if ($notnull_bool(options.showInfo)) {
     this.world.info(('[leg] ' + message + ''));
   }
 }
 WorldCompiler.prototype.run = function() {
   var success = Compiler.prototype.run.call(this);
   if ($notnull_bool(success)) {
@@ skipping 139 matching lines @@
 CompilerCancelledException.prototype.toString = function() {
   var banner = 'compiler cancelled';
   return (this.reason != null) ? ('' + banner + ': ' + this.reason + '') : ('' + banner + '');
 }
 CompilerCancelledException.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for ResolverTask **************
 function ResolverTask(compiler) {
   this.toResolve = new DoubleLinkedQueue();
+  // Initializers done
   CompilerTask.call(this, compiler);
-  // Initializers done
 }
 $inherits(ResolverTask, CompilerTask);
 ResolverTask.prototype.get$name = function() {
   return 'Resolver';
 }
 ResolverTask.prototype.resolve = function(tree) {
   var $this = this; // closure support
   var $0;
   return (($0 = this.measure((function () {
     var visitor = new ResolverVisitor($this.compiler);
@@ skipping 259 matching lines @@
   }
 }
 VariableDefinitionsVisitor.prototype.visit = function(node) {
   return node.accept(this);
 }
 VariableDefinitionsVisitor.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$Node()));
 };
 // ********** Code for Scope **************
 function Scope(parent) {
+  // Initializers done
   Scope.enclosing$ctor.call(this, parent, parent.enclosingElement);
-  // Initializers done
 }
 Scope.top$ctor = function() {
   this.parent = null;
   this.elements = const$250/*const {}*/;
   this.enclosingElement = null;
   // Initializers done
 }
 Scope.top$ctor.prototype = Scope.prototype;
 Scope.enclosing$ctor = function(parent, enclosingElement) {
   this.parent = parent;
@@ skipping 17 matching lines @@
 }
 Scope.prototype.add$1 = function($0) {
   return this.add(($0 && $0.is$Element()));
 };
 Scope.prototype.lookup$1 = function($0) {
   return this.lookup(($0 && $0.is$SourceString()));
 };
 // ********** Code for TopScope **************
 function TopScope(universe) {
   this.universe = universe;
+  // Initializers done
   Scope.top$ctor.call(this);
-  // Initializers done
 }
 $inherits(TopScope, Scope);
 TopScope.prototype.lookup = function(name) {
   return this.universe.find(name);
 }
 TopScope.prototype.add = function(element) {
   $throw("Cannot add an element in the top scope");
 }
 TopScope.prototype.add$1 = function($0) {
   return this.add(($0 && $0.is$Element()));
 };
 TopScope.prototype.lookup$1 = function($0) {
   return this.lookup(($0 && $0.is$SourceString()));
 };
 // ********** Code for leg_Script **************
 function leg_Script(file) {
   this.file = file;
   // Initializers done
 }
 leg_Script.prototype.get$text = function() {
   return this.file.get$text();
 }
 // ********** Code for TypeCheckerTask **************
 function TypeCheckerTask(compiler) {
   this.types = new Types();
+  // Initializers done
   CompilerTask.call(this, compiler);
-  // Initializers done
 }
 $inherits(TypeCheckerTask, CompilerTask);
 TypeCheckerTask.prototype.get$name = function() {
   return "Type checker";
 }
 TypeCheckerTask.prototype.check = function(tree, elements) {
   var $this = this; // closure support
   this.measure((function () {
     var visitor = new TypeCheckerVisitor($this.compiler, elements, $this.types);
     try {
@@ skipping 1179 matching lines @@
     }
     else {
       var paramValue = this._scope.declareParameter((p && p.is$Parameter()));
       this._paramCode.add(paramValue.code);
     }
   }
   var body = this.method.get$definition().body;
   if ($notnull_bool(body == null) && !$notnull_bool(this.method.get$isConstructor())) {
     world.error(('unexpected empty body for ' + this.method.name + ''), this.method.get$definition().get$span());
   }
+  var initializerCall = null;
+  var declaredInitializers = this.method.get$definition().initializers;
   if ($notnull_bool($ne(initializers, null))) {
     for (var $i = initializers.iterator$0(); $i.hasNext$0(); ) {
       var i = $i.next$0();
       this.writer.writeln($assert_String(i));
     }
-    var declaredInitializers = this.method.get$definition().initializers;
     if (declaredInitializers != null) {
-      var initializerCall = null;
       for (var $i = 0;$i < declaredInitializers.length; $i++) {
         var init = declaredInitializers.$index($i);
         if ((init instanceof CallExpression)) {
           if ($notnull_bool($ne(initializerCall, null))) {
             world.error('only one initializer redirecting call is allowed', init.get$span());
           }
           initializerCall = init;
         }
         else if ((init instanceof BinaryExpression) && TokenKind.kindFromAssign(init.op.kind) == 0) {
           var left = init.x;
@@ skipping 10 matching lines @@
             world.error(('"' + left.get$name().get$name() + '" does not refer to a field'), left.get$span());
             continue;
           }
           initializedFields.add$1(f.get$name());
           this.writer.writeln(('this.' + f.get$jsname() + ' = ' + this.visitValue(init.y).code + ';'));
         }
         else {
           world.error('invalid initializer', init.get$span());
         }
       }
-      if ($notnull_bool($ne(initializerCall, null))) {
-        var target = this._writeInitializerCall((initializerCall && initializerCall.is$CallExpression()));
-        if (!$notnull_bool(target.isSuper)) {
-          if (initializers.length > 0) {
-            var $list = this.method.get$parameters();
-            for (var $i = 0;$i < $list.length; $i++) {
-              var p = $list.$index($i);
-              if ($notnull_bool(p.isInitializer)) {
-                world.error('no initialization allowed on redirecting constructors', p.get$definition().get$span());
-                break;
-              }
-            }
-          }
-          if (declaredInitializers.length > 1) {
-            var init = $notnull_bool($eq(declaredInitializers.$index(0), initializerCall)) ? declaredInitializers.$index(1) : declaredInitializers.$index(0);
-            world.error('no initialization allowed on redirecting constructors', init.get$span());
-          }
-          initializedFields = null;
-        }
-      }
-      else {
-      }
     }
     this.writer.comment('// Initializers done');
   }
+  if ($notnull_bool(this.method.get$isConstructor()) && $notnull_bool(initializerCall == null)) {
+    var parentType = this.method.declaringType.get$parent();
+    if ($notnull_bool($ne(parentType, null)) && !$notnull_bool(parentType.get$isObject())) {
+      initializerCall = new CallExpression(new SuperExpression(this.method.get$span()), [], this.method.get$span());
+    }
+  }
+  if ($notnull_bool($ne(initializerCall, null))) {
+    var target = this._writeInitializerCall((initializerCall && initializerCall.is$CallExpression()));
+    if (!$notnull_bool(target.isSuper)) {
+      if (initializers.length > 0) {
+        var $list = this.method.get$parameters();
+        for (var $i = 0;$i < $list.length; $i++) {
+          var p = $list.$index($i);
+          if ($notnull_bool(p.isInitializer)) {
+            world.error('no initialization allowed on redirecting constructors', p.get$definition().get$span());
+            break;
+          }
+        }
+      }
+      if (declaredInitializers != null && declaredInitializers.length > 1) {
+        var init = $notnull_bool($eq(declaredInitializers.$index(0), initializerCall)) ? declaredInitializers.$index(1) : declaredInitializers.$index(0);
+        world.error('no initialization allowed on redirecting constructors', init.get$span());
+      }
+      initializedFields = null;
+    }
+  }
   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.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());
       }
     }
   }
@@ skipping 960 matching lines @@
 }
 MethodGenerator.prototype.visitSuperExpression = function(node) {
   return this._makeSuperValue(node);
 }
 MethodGenerator.prototype.visitNullExpression = function(node) {
   return EvaluatedValue.EvaluatedValue$factory(world.varType, null, 'null', null);
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   var $0;
   var type = node.type.type;
-  $assert($ne(type, null), "type != null", "gen.dart", 2099, 12);
+  $assert($ne(type, null), "type != null", "gen.dart", 2106, 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$lang_Expression()));
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
       var code = val.code;
       if ((item instanceof BinaryExpression) || (item instanceof ConditionalExpression)) {
         code = ('(' + code + ')');
@@ skipping 757 matching lines @@
 };
 Member.prototype.providePropertySyntax$0 = function() {
   return this.providePropertySyntax();
 };
 Member.prototype.resolve$1 = function($0) {
   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);
-  // Initializers done
 }
 $inherits(TypeMember, Member);
 TypeMember.prototype.is$TypeMember = function(){return this;};
 TypeMember.prototype.get$type = function() { return this.type; };
 TypeMember.prototype.get$span = function() {
   return this.type.definition.span;
 }
 TypeMember.prototype.get$isStatic = function() {
   return true;
 }
@@ skipping 44 matching lines @@
 TypeMember.prototype.resolve$1 = function($0) {
   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);
-  // Initializers done
 }
 $inherits(FieldMember, Member);
 FieldMember.prototype.is$FieldMember = function(){return this;};
 FieldMember.prototype.get$definition = function() { return this.definition; };
 FieldMember.prototype.get$value = function() { return this.value; };
 FieldMember.prototype.get$type = function() { return this.type; };
 FieldMember.prototype.set$type = function(value) { return this.type = value; };
 FieldMember.prototype.get$isStatic = function() { return this.isStatic; };
 FieldMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 FieldMember.prototype.get$isNative = function() { return this.isNative; };
@@ skipping 144 matching lines @@
 };
 FieldMember.prototype.providePropertySyntax$0 = function() {
   return this.providePropertySyntax();
 };
 FieldMember.prototype.resolve$1 = function($0) {
   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);
-  // Initializers done
 }
 $inherits(PropertyMember, Member);
 PropertyMember.prototype.is$PropertyMember = function(){return this;};
 PropertyMember.prototype.get$span = function() {
   var $0;
   return (($0 = this.getter != null ? this.getter.get$span() : null) && $0.is$SourceSpan());
 }
 PropertyMember.prototype.get$canGet = function() {
   return this.getter != null;
 }
@@ skipping 80 matching lines @@
 };
 PropertyMember.prototype.providePropertySyntax$0 = function() {
   return this.providePropertySyntax();
 };
 PropertyMember.prototype.resolve$1 = function($0) {
   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);
-  // Initializers done
   this.parameters = [];
   this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType);
   var $list = this.baseMember.get$parameters();
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
     var newType = p.type.resolveTypeParams$1(declaringType);
     if ($notnull_bool($ne(newType, p.type))) {
       this.parameters.add(p.copyWithNewType$1(newType));
     }
     else {
@@ skipping 62 matching lines @@
   return this.name == this.declaringType.name;
 }
 ConcreteMember.prototype.get$constructorName = function() {
   return this.baseMember.get$constructorName();
 }
 ConcreteMember.prototype.get$definition = function() {
   var $0;
   return (($0 = this.baseMember.get$definition()) && $0.is$Definition());
 }
 ConcreteMember.prototype.get$initDelegate = function() {
-  var $0;
-  return (($0 = this.baseMember.get$initDelegate()) && $0.is$Definition());
+  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$lang_Type());
 }
 ConcreteMember.prototype.override = function(other) {
@@ skipping 46 matching lines @@
 function MethodMember(name, declaringType, definition) {
   this.isStatic = false
   this.isAbstract = false
   this.isConst = false
   this.isFactory = false
   this.isLambda = false
   this._providePropertySyntax = false
   this._provideFieldSyntax = false
   this._provideOptionalParamInfo = false
   this.definition = definition;
+  // Initializers done
   Member.call(this, name, declaringType);
-  // Initializers done
 }
 $inherits(MethodMember, Member);
 MethodMember.prototype.is$MethodMember = function(){return this;};
 MethodMember.prototype.get$definition = function() { return this.definition; };
 MethodMember.prototype.set$definition = function(value) { return this.definition = value; };
 MethodMember.prototype.get$returnType = function() { return this.returnType; };
 MethodMember.prototype.set$returnType = function(value) { return this.returnType = value; };
 MethodMember.prototype.get$parameters = function() { return this.parameters; };
 MethodMember.prototype.set$parameters = function(value) { return this.parameters = value; };
 MethodMember.prototype.get$isStatic = function() { return this.isStatic; };
@@ skipping 1104 matching lines @@
 }
 InterpStack.prototype.next$0 = function() {
   return this.next();
 };
 // ********** Code for TokenizerBase **************
 function TokenizerBase(_source, _skipWhitespace, _index) {
   this._source = _source;
   this._skipWhitespace = _skipWhitespace;
   this._lang_index = _index;
   // Initializers done
+  TokenizerHelpers.call(this);
   this._text = this._source.get$text();
 }
 $inherits(TokenizerBase, TokenizerHelpers);
 TokenizerBase.prototype._nextChar = function() {
   if (this._lang_index < this._text.length) {
     return this._text.charCodeAt(this._lang_index++);
   }
   else {
     return 0;
   }
@@ skipping 310 matching lines @@
   }
   else {
     return this._finishToken(kind);
   }
 }
 TokenizerBase.prototype.next$0 = function() {
   return this.next();
 };
 // ********** Code for Tokenizer **************
 function Tokenizer(source, skipWhitespace, index) {
+  // Initializers done
   TokenizerBase.call(this, source, skipWhitespace, index);
-  // Initializers done
 }
 $inherits(Tokenizer, TokenizerBase);
 Tokenizer.prototype.next = function() {
   this._startIndex = this._lang_index;
   if (this._interpStack != null && this._interpStack.depth == 0) {
     var istack = this._interpStack;
     this._interpStack = this._interpStack.pop();
     if ($notnull_bool(istack.isMultiline)) {
       return this.finishMultilineString(istack.quote);
     }
@@ skipping 507 matching lines @@
     default:
 
       return 70/*TokenKind.IDENTIFIER*/;
 
   }
 }
 Tokenizer.prototype.next$0 = function() {
   return this.next();
 };
 // ********** Code for TokenizerHelpers **************
-function TokenizerHelpers() {}
+function TokenizerHelpers() {
+  // Initializers done
+}
 TokenizerHelpers.isIdentifierStart = function(c) {
   return ((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c == 95);
 }
 TokenizerHelpers.isDigit = function(c) {
   return (c >= 48 && c <= 57);
 }
 TokenizerHelpers.isHexDigit = function(c) {
   return ($notnull_bool(TokenizerHelpers.isDigit(c)) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70));
 }
 TokenizerHelpers.isWhitespace = function(c) {
@@ skipping 2373 matching lines @@
   // Initializers done
 }
 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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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 lang_Statement **************
 function lang_Statement(span) {
+  // Initializers done
   lang_Node.call(this, span);
-  // Initializers done
 }
 $inherits(lang_Statement, lang_Node);
 lang_Statement.prototype.is$lang_Statement = function(){return this;};
 // ********** Code for lang_Expression **************
 function lang_Expression(span) {
+  // Initializers done
   lang_Node.call(this, span);
-  // Initializers done
 }
 $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
   lang_Node.call(this, span);
-  // Initializers done
 }
 $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.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for DirectiveDefinition **************
 function DirectiveDefinition(name, arguments, span) {
   this.name = name;
   this.arguments = arguments;
+  // Initializers done
   Definition.call(this, span);
-  // Initializers done
 }
 $inherits(DirectiveDefinition, Definition);
 DirectiveDefinition.prototype.get$name = function() { return this.name; };
 DirectiveDefinition.prototype.set$name = function(value) { return this.name = value; };
 DirectiveDefinition.prototype.get$arguments = function() { return this.arguments; };
 DirectiveDefinition.prototype.set$arguments = function(value) { return this.arguments = value; };
 DirectiveDefinition.prototype.visit = function(visitor) {
   return visitor.visitDirectiveDefinition(this);
 }
 DirectiveDefinition.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for TypeDefinition **************
 function TypeDefinition(isClass, name, typeParameters, extendsTypes, implementsTypes, nativeType, factoryType, body, span) {
   this.isClass = isClass;
   this.name = name;
   this.typeParameters = typeParameters;
   this.extendsTypes = extendsTypes;
   this.implementsTypes = implementsTypes;
   this.nativeType = nativeType;
   this.factoryType = factoryType;
   this.body = body;
+  // Initializers done
   Definition.call(this, span);
-  // Initializers done
 }
 $inherits(TypeDefinition, Definition);
 TypeDefinition.prototype.is$TypeDefinition = function(){return this;};
 TypeDefinition.prototype.get$isClass = function() { return this.isClass; };
 TypeDefinition.prototype.set$isClass = function(value) { return this.isClass = value; };
 TypeDefinition.prototype.get$name = function() { return this.name; };
 TypeDefinition.prototype.set$name = function(value) { return this.name = value; };
 TypeDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
 TypeDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 TypeDefinition.prototype.get$nativeType = function() { return this.nativeType; };
 TypeDefinition.prototype.set$nativeType = function(value) { return this.nativeType = value; };
 TypeDefinition.prototype.visit = function(visitor) {
   return visitor.visitTypeDefinition(this);
 }
 TypeDefinition.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for FunctionTypeDefinition **************
 function FunctionTypeDefinition(func, typeParameters, span) {
   this.func = func;
   this.typeParameters = typeParameters;
+  // Initializers done
   Definition.call(this, span);
-  // Initializers done
 }
 $inherits(FunctionTypeDefinition, Definition);
 FunctionTypeDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
 FunctionTypeDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 FunctionTypeDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeDefinition(this);
 }
 FunctionTypeDefinition.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for VariableDefinition **************
 function VariableDefinition(modifiers, type, names, values, span) {
   this.modifiers = modifiers;
   this.type = type;
   this.names = names;
   this.values = values;
+  // Initializers done
   Definition.call(this, span);
-  // Initializers done
 }
 $inherits(VariableDefinition, Definition);
 VariableDefinition.prototype.get$type = function() { return this.type; };
 VariableDefinition.prototype.set$type = function(value) { return this.type = value; };
 VariableDefinition.prototype.visit = function(visitor) {
   return visitor.visitVariableDefinition(this);
 }
 VariableDefinition.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for FunctionDefinition **************
 function FunctionDefinition(modifiers, returnType, name, formals, initializers, body, span) {
   this.modifiers = modifiers;
   this.returnType = returnType;
   this.name = name;
   this.formals = formals;
   this.initializers = initializers;
   this.body = body;
+  // Initializers done
   Definition.call(this, span);
-  // Initializers done
 }
 $inherits(FunctionDefinition, Definition);
 FunctionDefinition.prototype.is$FunctionDefinition = function(){return this;};
 FunctionDefinition.prototype.get$returnType = function() { return this.returnType; };
 FunctionDefinition.prototype.set$returnType = function(value) { return this.returnType = value; };
 FunctionDefinition.prototype.get$name = function() { return this.name; };
 FunctionDefinition.prototype.set$name = function(value) { return this.name = value; };
 FunctionDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
 }
 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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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 lang_ExpressionStatement **************
 function lang_ExpressionStatement(body, span) {
   this.body = body;
+  // Initializers done
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $inherits(lang_ExpressionStatement, lang_Statement);
 lang_ExpressionStatement.prototype.visit = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
 lang_ExpressionStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for EmptyStatement **************
 function EmptyStatement(span) {
+  // Initializers done
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Statement.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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 lang_NewExpression **************
 function lang_NewExpression(isConst, type, name, arguments, span) {
   this.isConst = isConst;
   this.type = type;
   this.name = name;
   this.arguments = arguments;
+  // Initializers done
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $inherits(lang_NewExpression, lang_Expression);
 lang_NewExpression.prototype.get$isConst = function() { return this.isConst; };
 lang_NewExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 lang_NewExpression.prototype.get$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);
 }
 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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for NameTypeReference **************
 function NameTypeReference(isFinal, name, names, span) {
   this.isFinal = isFinal;
   this.name = name;
   this.names = names;
+  // Initializers done
   TypeReference.call(this, span);
-  // Initializers done
 }
 $inherits(NameTypeReference, TypeReference);
 NameTypeReference.prototype.is$NameTypeReference = function(){return this;};
 NameTypeReference.prototype.get$name = function() { return this.name; };
 NameTypeReference.prototype.set$name = function(value) { return this.name = value; };
 NameTypeReference.prototype.visit = function(visitor) {
   return visitor.visitNameTypeReference(this);
 }
 NameTypeReference.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for GenericTypeReference **************
 function GenericTypeReference(baseType, typeArguments, depth, span) {
   this.baseType = baseType;
   this.typeArguments = typeArguments;
   this.depth = depth;
+  // Initializers done
   TypeReference.call(this, span);
-  // Initializers done
 }
 $inherits(GenericTypeReference, TypeReference);
 GenericTypeReference.prototype.is$GenericTypeReference = function(){return this;};
 GenericTypeReference.prototype.visit = function(visitor) {
   return visitor.visitGenericTypeReference(this);
 }
 GenericTypeReference.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for FunctionTypeReference **************
 function FunctionTypeReference(isFinal, func, span) {
   this.isFinal = isFinal;
   this.func = func;
+  // Initializers done
   TypeReference.call(this, span);
-  // Initializers done
 }
 $inherits(FunctionTypeReference, TypeReference);
 FunctionTypeReference.prototype.is$FunctionTypeReference = function(){return this;};
 FunctionTypeReference.prototype.visit = function(visitor) {
   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
   lang_Node.call(this, span);
-  // Initializers done
 }
 $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
   lang_Node.call(this, span);
-  // Initializers done
 }
 $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
   lang_Node.call(this, span);
-  // Initializers done
 }
 $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
   lang_Node.call(this, span);
-  // Initializers done
 }
 $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
   lang_Node.call(this, span);
-  // Initializers done
 }
 $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 lang_Identifier **************
 function lang_Identifier(name, span) {
   this.name = name;
+  // Initializers done
   lang_Node.call(this, span);
-  // Initializers done
 }
 $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);
 }
 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
   lang_Expression.call(this, span);
-  // Initializers done
 }
 $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);
 }
@@ skipping 244 matching lines @@
 };
 lang_Type.prototype.resolveMember$1 = function($0) {
   return this.resolveMember($assert_String($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
   lang_Type.call(this, name);
-  // Initializers done
 }
 $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() {
@@ skipping 52 matching lines @@
 };
 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
   lang_Type.call(this, type.name);
-  // Initializers done
 }
 $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() {
@@ skipping 120 matching lines @@
   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
   lang_Type.call(this, name);
-  // Initializers done
 }
 $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() {
@@ skipping 152 matching lines @@
 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
   lang_Type.call(this, name);
-  // Initializers done
   this.setDefinition(definition);
 }
 $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;
@@ skipping 1029 matching lines @@
   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$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);
-  // Initializers done
 }
 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$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
-  // Initializers done
 }
 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$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
-  // Initializers done
 }
 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$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
-  // Initializers done
 }
 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() + ''));
   }
   fieldValues.sort((function (a, b) {
     return a.compareTo$1(b);
   })
   );
   var actualValue = ('const ' + type.get$jsname() + ' [') + Strings.join(fieldValues, ',') + ']';
   return new ConstObjectValue._internal$ctor(type, fields, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 // ********** Code for GlobalValue **************
 function GlobalValue(type, code, isConst, field, name, exp, canonicalCode, span, dependencies) {
   this.field = field;
   this.name = name;
   this.exp = exp;
   this.canonicalCode = canonicalCode;
   this.dependencies = dependencies;
+  // Initializers done
   Value.call(this, type, code, span, !$notnull_bool(isConst));
-  // Initializers done
 }
 $inherits(GlobalValue, Value);
 GlobalValue.prototype.is$GlobalValue = function(){return this;};
 GlobalValue.prototype.is$Comparable = function(){return this;};
 GlobalValue.GlobalValue$fromStatic$factory = function(field, exp, dependencies) {
   var code = ($notnull_bool(exp.get$isConst()) ? exp.get$canonicalCode() : exp.code);
   var codeWithComment = ('' + code + '/*' + field.declaringType.name + '.' + field.get$name() + '*/');
   return new GlobalValue(exp.type, $assert_String(codeWithComment), field.isFinal, field, null, exp, code, exp.span, dependencies.filter$1((function (d) {
     return (d instanceof GlobalValue);
   })
@@ skipping 45 matching lines @@
   else {
     return this.field.name.compareTo(other.field.name);
   }
 }
 GlobalValue.prototype.compareTo$1 = function($0) {
   return this.compareTo(($0 && $0.is$GlobalValue()));
 };
 // ********** Code for BareValue **************
 function BareValue(home, outermost, span) {
   this.home = home;
+  // Initializers done
   Value.call(this, outermost.method.declaringType, null, span, false);
-  // Initializers done
   this.isType = outermost.get$isStatic();
 }
 $inherits(BareValue, Value);
 BareValue.prototype._tryResolveMember = function(context, name) {
   $assert($eq(context, this.home), "context == home", "value.dart", 685, 12);
   var member = this.type.resolveMember(name);
   if ($notnull_bool($ne(member, null))) {
     $assert(this.code == null, "code == null", "value.dart", 690, 14);
     if ($notnull_bool(this.isType)) {
       this.code = this.type.get$jsname();
@@ skipping 491 matching lines @@
 }
 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$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);
-  // Initializers done
   world.gen.corejs.useGenStub = true;
 }
 $inherits(VarFunctionStub, VarMember);
 VarFunctionStub.prototype.is$VarFunctionStub = function(){return this;};
 VarFunctionStub.prototype.generate = function(code) {
   if ($notnull_bool(this.args.get$hasNames())) {
     this.generateNamed(code);
   }
   else {
     this.generatePositional(code);
@@ skipping 21 matching lines @@
   w.exitBlock('}');
 }
 VarFunctionStub.prototype.generate$1 = function($0) {
   return this.generate(($0 && $0.is$CodeWriter()));
 };
 // ********** Code for VarMethodStub **************
 function VarMethodStub(name, member, args, body) {
   this.member = member;
   this.args = args;
   this.body = body;
+  // Initializers done
   VarMember.call(this, name);
-  // Initializers done
 }
 $inherits(VarMethodStub, VarMember);
 VarMethodStub.prototype.get$returnType = function() {
   var $0;
   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) {
@@ skipping 32 matching lines @@
   return this.generate(($0 && $0.is$CodeWriter()));
 };
 VarMethodStub.prototype.generateBody$2 = function($0, $1) {
   return this.generateBody(($0 && $0.is$CodeWriter()), $assert_String($1));
 };
 // ********** Code for VarMethodSet **************
 function VarMethodSet(name, members, callArgs, returnType) {
   this.members = members;
   this.returnType = returnType;
   this.args = callArgs.toCallStubArgs();
+  // Initializers done
   VarMember.call(this, name);
-  // Initializers done
 }
 $inherits(VarMethodSet, VarMember);
 VarMethodSet.prototype.get$members = function() { return this.members; };
 VarMethodSet.prototype.get$returnType = function() { return this.returnType; };
 VarMethodSet.prototype.get$baseName = function() {
   return $assert_String(this.members.$index(0).get$name());
 }
 VarMethodSet.prototype.invoke = function(context, node, target, args) {
   this._invokeMembers(context, node);
   return VarMember.prototype.invoke.call(this, context, node, target, args);
@@ skipping 480 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();