Frog: preserve initialization order.

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 function $defProp(obj, prop, value) {
   Object.defineProperty(obj, prop,
       {value: value, enumerable: false, writable: true, configurable: true});
 }
 Function.prototype.bind = Function.prototype.bind ||
   function(thisObj) {
     var func = this;
@@ skipping 330 matching lines @@
 // ********** Code for IllegalAccessException **************
 function IllegalAccessException() {
 
 }
 IllegalAccessException.prototype.toString = function() {
   return "Attempt to modify an immutable object";
 }
 IllegalAccessException.prototype.toString$0 = IllegalAccessException.prototype.toString;
 // ********** Code for NoSuchMethodException **************
 function NoSuchMethodException(_receiver, _functionName, _arguments, _existingArgumentNames) {
-  this._existingArgumentNames = _existingArgumentNames;
   this._receiver = _receiver;
   this._functionName = _functionName;
   this._arguments = _arguments;
+  this._existingArgumentNames = _existingArgumentNames;
 }
 NoSuchMethodException.prototype.is$NoSuchMethodException = function(){return true};
 NoSuchMethodException.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   for (var i = (0);
    i < this._arguments.get$length(); i++) {
     if (i > (0)) {
       sb.add(", ");
     }
     sb.add(this._arguments.$index(i));
@@ skipping 381 matching lines @@
   return this.re.test(str);
 }
 JSSyntaxRegExp.prototype.allMatches = function(str) {
   return new _AllMatchesIterable(this, str);
 }
 JSSyntaxRegExp.prototype.get$_global = function() {
   return new JSSyntaxRegExp._create$ctor(this.pattern, $add$($add$("g", (this.multiLine ? "m" : "")), (this.ignoreCase ? "i" : "")));
 }
 // ********** Code for MatchImplementation **************
 function MatchImplementation(pattern, str, _start, _end, _groups) {
+  this.pattern = pattern;
   this.str = str;
   this._start = _start;
+  this._end = _end;
   this._groups = _groups;
-  this.pattern = pattern;
-  this._end = _end;
 }
 MatchImplementation.prototype.start = function() {
   return this._start;
 }
 MatchImplementation.prototype.get$start = function() {
   return this.start.bind(this);
 }
 MatchImplementation.prototype.end = function() {
   return this._end;
 }
 MatchImplementation.prototype.$index = function(group) {
   return this._groups.$index(group);
 }
 MatchImplementation.prototype.end$0 = MatchImplementation.prototype.end;
 // ********** Code for _AllMatchesIterable **************
 function _AllMatchesIterable(_re, _str) {
   this._re = _re;
   this._str = _str;
 }
 _AllMatchesIterable.prototype.iterator = function() {
   return new _AllMatchesIterator(this._re, this._str);
 }
 // ********** Code for _AllMatchesIterator **************
 function _AllMatchesIterator(re, _str) {
+  this._str = _str;
   this._done = false;
   this._re = re.get$_global();
-  this._str = _str;
 }
 _AllMatchesIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$0001);
   }
   var next = this._next;
   this._next = null;
   return next;
 }
 _AllMatchesIterator.prototype.hasNext = function() {
@@ skipping 440 matching lines @@
 HashSetImplementation_Member.prototype.is$Collection = function(){return true};
 // ********** Code for HashSetImplementation_Type **************
 $inherits(HashSetImplementation_Type, HashSetImplementation);
 function HashSetImplementation_Type() {
   this._backingMap = new HashMapImplementation_Type$Type();
 }
 HashSetImplementation_Type.prototype.is$Collection = function(){return true};
 HashSetImplementation_Type.prototype.contains$1 = HashSetImplementation_Type.prototype.contains;
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
+  this._nextValidIndex = (-1);
   this._entries = set_._backingMap._keys;
-  this._nextValidIndex = (-1);
   this._advance();
 }
 HashSetIterator.prototype.hasNext = function() {
   var $0;
   if (this._nextValidIndex >= this._entries.get$length()) return false;
   if ((($0 = this._entries.$index(this._nextValidIndex)) == null ? null == (const$0000) : $0 === const$0000)) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.get$length();
 }
@@ skipping 14 matching lines @@
     entry = this._entries.$index(this._nextValidIndex);
   }
   while ((null == entry) || ((null == entry ? null == (deletedKey) : entry === deletedKey)))
 }
 // ********** Code for _DeletedKeySentinel **************
 function _DeletedKeySentinel() {
 
 }
 // ********** Code for KeyValuePair **************
 function KeyValuePair(key, value) {
+  this.key = key;
   this.value = value;
-  this.key = key;
 }
 KeyValuePair.prototype.get$value = function() { return this.value; };
 KeyValuePair.prototype.set$value = function(value) { return this.value = value; };
 // ********** Code for LinkedHashMapImplementation **************
 function LinkedHashMapImplementation() {
   this._map = new HashMapImplementation_Dynamic$DoubleLinkedQueueEntry_KeyValuePair();
   this._list = new DoubleLinkedQueue_KeyValuePair();
 }
 LinkedHashMapImplementation.prototype.is$Map = function(){return true};
 LinkedHashMapImplementation.prototype.$setindex = function(key, value) {
@@ skipping 520 matching lines @@
   var ret = new LinkedHashMapImplementation();
   for (var i = (0);
    i < itemsAndKeys.get$length(); ) {
     ret.$setindex(itemsAndKeys.$index(i++), itemsAndKeys.$index(i++));
   }
   return ret;
 }
 //  ********** Library node **************
 // ********** Code for Process **************
 function Process(_process) {
-  this.SIGSYS = "SIGSYS";
-  this.SIGALRM = "SIGALRM";
-  this.SIGXCPU = "SIGXCPU";
-  this.SIGTSTP = "SIGTSTP";
-  this.SIGSEGV = "SIGSEGV";
+  this.SIGHUP = "SIGHUP";
+  this.SIGINT = "SIGINT";
   this.SIGQUIT = "SIGQUIT";
-  this.SIGABRT = "SIGABRT";
-  this.SIGKILL = "SIGKILL";
-  this.SIGHUP = "SIGHUP";
-  this.SIGUSR2 = "SIGUSR2";
-  this.SIGXFSZ = "SIGXFSZ";
-  this.SIGCONT = "SIGCONT";
-  this.SIGTTOU = "SIGTTOU";
-  this.SIGINT = "SIGINT";
-  this.SIGURG = "SIGURG";
-  this.SIGFPE = "SIGFPE";
-  this.SIGUSR1 = "SIGUSR1";
-  this.SIGEMT = "SIGEMT";
-  this.SIGPIPE = "SIGPIPE";
-  this.SIGTTIN = "SIGTTIN";
-  this.SIGTERM = "SIGTERM";
-  this._process = _process;
-  this.SIGBUS = "SIGBUS";
-  this.SIGPROF = "SIGPROF";
-  this.SIGSTOP = "SIGSTOP";
-  this.SIGCHLD = "SIGCHLD";
   this.SIGILL = "SIGILL";
   this.SIGTRAP = "SIGTRAP";
+  this.SIGABRT = "SIGABRT";
+  this.SIGEMT = "SIGEMT";
+  this.SIGFPE = "SIGFPE";
+  this.SIGKILL = "SIGKILL";
+  this.SIGBUS = "SIGBUS";
+  this.SIGSEGV = "SIGSEGV";
+  this.SIGSYS = "SIGSYS";
+  this.SIGPIPE = "SIGPIPE";
+  this.SIGALRM = "SIGALRM";
+  this.SIGTERM = "SIGTERM";
+  this.SIGURG = "SIGURG";
+  this.SIGSTOP = "SIGSTOP";
+  this.SIGTSTP = "SIGTSTP";
+  this.SIGCONT = "SIGCONT";
+  this.SIGCHLD = "SIGCHLD";
+  this.SIGTTIN = "SIGTTIN";
+  this.SIGTTOU = "SIGTTOU";
+  this.SIGIO = "SIGIO";
+  this.SIGXCPU = "SIGXCPU";
+  this.SIGXFSZ = "SIGXFSZ";
+  this.SIGVTALRM = "SIGVTALRM";
+  this.SIGPROF = "SIGPROF";
+  this.SIGWINCH = "SIGWINCH";
   this.SIGINFO = "SIGINFO";
-  this.SIGIO = "SIGIO";
-  this.SIGVTALRM = "SIGVTALRM";
-  this.SIGWINCH = "SIGWINCH";
+  this.SIGUSR1 = "SIGUSR1";
+  this.SIGUSR2 = "SIGUSR2";
+  this._process = _process;
 }
 Process.prototype.get$argv = function() {
   return this._process.argv;
 }
 Process.prototype.set$argv = function(value) {
   this._process.argv = value;
 }
 Process.prototype.get$env = function() {
   return new EnvMap(this._process);
 }
@@ skipping 173 matching lines @@
 NodeFileSystem.prototype.readAll = function(filename) {
   return fs.readFileSync(filename, "utf8");
 }
 NodeFileSystem.prototype.fileExists = function(filename) {
   return path.existsSync(filename);
 }
 // ********** Code for top level **************
 //  ********** Library lang **************
 // ********** Code for MethodAnalyzer **************
 function MethodAnalyzer(method, body) {
+  this.hasTypeParams = false;
   this.method = method;
   this.body = body;
-  this.hasTypeParams = false;
 }
 MethodAnalyzer.prototype.get$method = function() { return this.method; };
 MethodAnalyzer.prototype.get$body = function() { return this.body; };
 MethodAnalyzer.prototype.get$hasTypeParams = function() { return this.hasTypeParams; };
 MethodAnalyzer.prototype.analyze = function(context) {
   var thisValue;
   if (context != null) {
     thisValue = context.thisValue;
   }
   else {
@@ skipping 608 matching lines @@
   return this.visitBinaryExpression($0, false);
 };
 MethodAnalyzer.prototype.visitCallExpression$1 = function($0) {
   return this.visitCallExpression($0, false);
 };
 MethodAnalyzer.prototype.visitPostfixExpression$1 = function($0) {
   return this.visitPostfixExpression($0, false);
 };
 // ********** Code for CallFrame **************
 function CallFrame(analyzer, method, thisValue, args, enclosingFrame) {
-  this.args = args;
   this.analyzer = analyzer;
-  this.enclosingFrame = enclosingFrame;
   this.method = method;
   this.thisValue = thisValue;
+  this.args = args;
+  this.enclosingFrame = enclosingFrame;
   this._slots = [];
   this._scope = new AnalyzeScope(null, this, this.analyzer.body);
   this._returnSlot = new VariableSlot(this._scope, "return", this.method.returnType, this.analyzer.body, false);
 }
 CallFrame.prototype.findMembers = function(name) {
   return this.get$library()._findMembers(name);
 }
 CallFrame.prototype.get$counters = function() {
   return $globals.world.counters;
 }
@@ skipping 66 matching lines @@
   return new PureStaticValue(type, node == null ? null : node.span, false, false);
 }
 CallFrame.prototype.makeSuperValue = function(node) {
   return this._makeValue(this.thisValue.get$type().get$parent(), node);
 }
 CallFrame.prototype.makeThisValue = function(node) {
   return this._makeValue(this.thisValue.get$type(), node);
 }
 // ********** Code for VariableSlot **************
 function VariableSlot(scope, name, staticType, node, isFinal, value) {
+  this.scope = scope;
+  this.name = name;
+  this.staticType = staticType;
+  this.node = node;
+  this.isFinal = isFinal;
   this.value = value;
-  this.name = name;
-  this.scope = scope;
-  this.node = node;
-  this.staticType = staticType;
-  this.isFinal = isFinal;
   if (null != this.value) {
     this.value = this.value.convertTo(this.scope.frame, this.staticType);
   }
 }
 VariableSlot.prototype.get$scope = function() { return this.scope; };
 VariableSlot.prototype.get$name = function() { return this.name; };
 VariableSlot.prototype.get$staticType = function() { return this.staticType; };
 VariableSlot.prototype.get$isFinal = function() { return this.isFinal; };
 VariableSlot.prototype.get$value = function() { return this.value; };
 VariableSlot.prototype.set$value = function(value) { return this.value = value; };
 VariableSlot.prototype.get = function(position) {
   return this.scope.frame._makeValue(this.staticType, position);
 }
 VariableSlot.prototype.set = function(newValue) {
   if (null != newValue) {
     newValue = newValue.convertTo(this.scope.frame, this.staticType);
   }
   this.value = Value.union(this.value, newValue);
 }
 VariableSlot.prototype.toString = function() {
   var valueString = null != this.value ? (" = " + this.value.get$type().name) : "";
   return ("" + this.staticType.name + " " + this.name + valueString);
 }
 VariableSlot.prototype.toString$0 = VariableSlot.prototype.toString;
 // ********** Code for AnalyzeScope **************
 function AnalyzeScope(parent, frame, node) {
+  this.parent = parent;
   this.frame = frame;
-  this.parent = parent;
   this.node = node;
   this._slots = [];
 }
 AnalyzeScope.prototype.get$parent = function() { return this.parent; };
 AnalyzeScope.prototype.get$_slots = function() { return this._slots; };
 AnalyzeScope.prototype._lookup = function(name) {
   for (var s = this;
    $ne$(s); s = s.get$parent()) {
     for (var i = (0);
      i < s.get$_slots().get$length(); i++) {
       var ret = s.get$_slots().$index(i);
       if ($eq$(ret.get$name(), name)) return ret;
     }
   }
   return null;
 }
 // ********** Code for BlockScope **************
 function BlockScope(enclosingMethod, parent, node, reentrant) {
   this.enclosingMethod = enclosingMethod;
-  this._vars = new CopyOnWriteMap_dart_core_String$VariableValue();
   this.parent = parent;
   this.node = node;
   this.reentrant = reentrant;
+  this._vars = new CopyOnWriteMap_dart_core_String$VariableValue();
   this._jsNames = new HashSetImplementation_dart_core_String();
   if (this.get$isMethodScope()) {
     this._closedOver = new HashSetImplementation_dart_core_String();
   }
   else {
     this.reentrant = reentrant || this.parent.reentrant;
   }
   this.inferTypes = $globals.options.inferTypes && (this.parent == null || this.parent.inferTypes);
 }
 BlockScope._snapshot$ctor = function(original) {
   this.enclosingMethod = original.enclosingMethod;
+  this.parent = original.parent == null ? null : original.parent.snapshot();
   this._vars = original._vars.clone();
-  this.parent = original.parent == null ? null : original.parent.snapshot();
   this.node = original.node;
   this.inferTypes = original.inferTypes;
+  this.rethrow = original.rethrow;
   this._jsNames = original._jsNames;
   this._closedOver = original._closedOver;
-  this.rethrow = original.rethrow;
 }
 BlockScope._snapshot$ctor.prototype = BlockScope.prototype;
 BlockScope.prototype.get$enclosingMethod = function() { return this.enclosingMethod; };
 BlockScope.prototype.get$parent = function() { return this.parent; };
 BlockScope.prototype.get$_vars = function() { return this._vars; };
 BlockScope.prototype.get$_jsNames = function() { return this._jsNames; };
 BlockScope.prototype.get$_closedOver = function() { return this._closedOver; };
 BlockScope.prototype.get$rethrow = function() { return this.rethrow; };
 BlockScope.prototype.get$isMethodScope = function() {
   return this.parent == null || $ne$(this.parent.enclosingMethod, this.enclosingMethod);
@@ skipping 99 matching lines @@
     );
   }
   return changed;
 }
 BlockScope.prototype.create$3$isFinal = function($0, $1, $2, isFinal) {
   return this.create($0, $1, $2, isFinal, false);
 };
 // ********** Code for CodeWriter **************
 function CodeWriter() {
   this._indentation = (0);
+  this._pendingIndent = false;
   this.writeComments = true;
-  this._pendingIndent = false;
   this._buf = new StringBufferImpl("");
 }
 CodeWriter.prototype.get$text = function() {
   return this._buf.toString();
 }
 CodeWriter.prototype._indent = function() {
   this._pendingIndent = false;
   for (var i = (0);
    i < this._indentation; i++) {
     this._buf.add("  ");
@@ skipping 42 matching lines @@
   this.writeln(text);
 }
 CodeWriter.prototype.nextBlock = function(text) {
   this._indentation--;
   this.writeln(text);
   this._indentation++;
 }
 CodeWriter.prototype.write$1 = CodeWriter.prototype.write;
 // ********** Code for CoreJs **************
 function CoreJs() {
+  this.useThrow = false;
+  this.useNotNullBool = false;
+  this.useIndex = false;
+  this.useSetIndex = false;
+  this.useWrap0 = false;
+  this.useWrap1 = false;
   this.useIsolates = false;
   this._generatedTypeNameOf = false;
+  this._generatedDynamicProto = false;
+  this._generatedDynamicSetMetadata = false;
+  this._generatedInherits = false;
+  this._generatedDefProp = false;
+  this._generatedBind = false;
   this._usedOperators = new HashMapImplementation();
-  this._generatedInherits = false;
-  this.useNotNullBool = false;
-  this._generatedDynamicSetMetadata = false;
   this.writer = new CodeWriter();
-  this.useWrap0 = false;
-  this.useThrow = false;
-  this._generatedDynamicProto = false;
-  this._generatedBind = false;
-  this.useWrap1 = false;
-  this.useSetIndex = false;
-  this.useIndex = false;
-  this._generatedDefProp = false;
 }
 CoreJs.prototype.get$writer = function() { return this.writer; };
 CoreJs.prototype.set$writer = function(value) { return this.writer = value; };
 CoreJs.prototype.markCorelibTypeUsed = function(typeName) {
   $globals.world.gen.markTypeUsed($globals.world.corelib.types.$index(typeName));
 }
 CoreJs.prototype.useOperator = function(name) {
   if ($ne$(this._usedOperators.$index(name))) return;
   if (name != ":ne" && name != ":eq") {
     this.markCorelibTypeUsed("NoSuchMethodException");
@@ skipping 257 matching lines @@
   return (10);
 }
 ExistingJsGlobal.prototype.get$span = function() {
   return this.declaringElement.get$span();
 }
 ExistingJsGlobal.prototype.get$library = function() {
   return this.declaringElement.get$library();
 }
 // ********** Code for WorldGenerator **************
 function WorldGenerator(main, writer) {
+  this.hasStatics = false;
   this.main = main;
-  this.hasStatics = false;
+  this.writer = writer;
+  this.globals = new HashMapImplementation();
   this.corejs = new CoreJs();
-  this.globals = new HashMapImplementation();
-  this.writer = writer;
 }
 WorldGenerator.prototype.get$writer = function() { return this.writer; };
 WorldGenerator.prototype.set$writer = function(value) { return this.writer = value; };
 WorldGenerator.prototype.analyze = function() {
   var nlibs = (0), ntypes = (0), nmems = (0), nnews = (0);
   var $$list = $globals.world.libraries.getValues();
   for (var $$i = $$list.iterator(); $$i.hasNext(); ) {
     var lib = $$i.next();
     nlibs += (1);
     var $list0 = lib.get$types().getValues();
@@ skipping 555 matching lines @@
   if ($eq$(x.get$name())) return (-1);
   if ($eq$(y.get$name())) return (1);
   return x.get$name().compareTo(y.get$name());
 }
 WorldGenerator.prototype.get$_compareMembers = function() {
   return this._compareMembers.bind(this);
 }
 WorldGenerator.prototype.run$0 = WorldGenerator.prototype.run;
 // ********** Code for MethodGenerator **************
 function MethodGenerator(method, enclosingMethod) {
+  this.method = method;
   this.enclosingMethod = enclosingMethod;
+  this.writer = new CodeWriter();
   this.needsThis = false;
-  this.method = method;
-  this.writer = new CodeWriter();
   if (this.enclosingMethod != null) {
     this._scope = new BlockScope(this, this.enclosingMethod._scope, this.method.get$definition(), false);
     this.captures = new HashSetImplementation();
   }
   else {
     this._scope = new BlockScope(this, null, this.method.get$definition(), false);
   }
   this._usedTemps = new HashSetImplementation();
   this._freeTemps = [];
   this.counters = $globals.world.counters;
@@ skipping 266 matching lines @@
     }
   }
   if (this.method.get$isConstructor() && $eq$(initializerCall) && !this.method.get$isNative()) {
     var parentType = this.method.declaringType.get$parent();
     if ($ne$(parentType) && !parentType.get$isObject()) {
       initializerCall = new CallExpression(new SuperExpression(this.method.get$span()), [], this.method.get$span());
     }
   }
   if (this.method.get$isConstructor() && (newObject instanceof ObjectValue)) {
     var fields = newObject.get$dynamic().get$fields();
-    var $$list = fields.getKeys();
+    var $$list = newObject.get$dynamic().get$fieldsInInitOrder();
     for (var $$i = $$list.iterator(); $$i.hasNext(); ) {
       var field = $$i.next();
-      var value = fields.$index(field);
-      if (null != value) {
-        this.writer.writeln(("this." + field.get$jsname() + " = " + value.get$code() + ";"));
+      if (null != field) {
+        var value = fields.$index(field);
+        if (null != value) {
+          this.writer.writeln(("this." + field.get$jsname() + " = " + value.get$code() + ";"));
+        }
       }
     }
   }
   if ($ne$(initializerCall)) {
     this.evalInitializerCall(newObject, initializerCall, fieldsSet);
   }
   if (this.method.get$isConstructor() && null != newObject && newObject.get$isConst()) {
     newObject.validateInitialized(this.method.get$span());
   }
   else if (this.method.get$isConstructor()) {
@@ skipping 1105 matching lines @@
    i < this.get$bareCount(); i++) {
     if ($ne$(this.values.$index(i).get$type(), other.values.$index(i).get$type())) return false;
   }
   return true;
 }
 // ********** Code for ReturnKind **************
 function ReturnKind() {}
 // ********** Code for LibraryImport **************
 function LibraryImport(library, prefix, span) {
   this.library = library;
+  this.prefix = prefix;
   this.span = span;
-  this.prefix = prefix;
 }
 LibraryImport.prototype.get$prefix = function() { return this.prefix; };
 LibraryImport.prototype.get$library = function() { return this.library; };
 LibraryImport.prototype.get$span = function() { return this.span; };
 // ********** Code for Member **************
 $inherits(Member, Element);
 function Member(name, declaringType) {
   this._provideGetter = false;
   this._provideSetter = false;
   this.declaringType = declaringType;
@@ skipping 211 matching lines @@
 // ********** Code for AmbiguousMember **************
 $inherits(AmbiguousMember, Member);
 function AmbiguousMember(name, members) {
   this.members = members;
   Member.call(this, name, null);
 }
 AmbiguousMember.prototype.get$members = function() { return this.members; };
 // ********** Code for Library **************
 $inherits(Library, Element);
 function Library(baseSource) {
+  this.isWritten = false;
   this.baseSource = baseSource;
-  this.isWritten = false;
   Element.call(this, null, null);
   this.sourceDir = dirname(this.baseSource.filename);
   this.topType = new DefinedType(null, this, null, true);
   this.types = _map(["", this.topType]);
   this.imports = [];
   this.natives = [];
   this.sources = [];
   this._privateMembers = new HashMapImplementation();
 }
 Library.prototype.get$baseSource = function() { return this.baseSource; };
@@ skipping 236 matching lines @@
 }
 Library.prototype.hashCode = function() {
   return this.baseSource.filename.hashCode();
 }
 Library.prototype.$eq = function(other) {
   return (other instanceof Library) && other.get$baseSource().filename == this.baseSource.filename;
 }
 Library.prototype.toString$0 = Library.prototype.toString;
 // ********** Code for _LibraryVisitor **************
 function _LibraryVisitor(library) {
-  this.library = library;
-  this.isTop = true;
+  this.seenImport = false;
   this.seenSource = false;
   this.seenResource = false;
-  this.seenImport = false;
+  this.isTop = true;
+  this.library = library;
   this.currentType = this.library.topType;
   this.sources = [];
 }
 _LibraryVisitor.prototype.get$library = function() { return this.library; };
 _LibraryVisitor.prototype.get$isTop = function() { return this.isTop; };
 _LibraryVisitor.prototype.addSourceFromName = function(name, span) {
   var filename = this.library.makeFullPath(name);
   if ($eq$(filename, this.library.baseSource.filename)) {
     $globals.world.error("library cannot source itself", span);
     return;
@@ skipping 164 matching lines @@
 }
 _LibraryVisitor.prototype.visitFunctionDefinition = function(node) {
   this.currentType.addMethod(node.name.name, node);
 }
 _LibraryVisitor.prototype.visitFunctionTypeDefinition = function(node) {
   var type = this.library.addType(node.func.name.name, node, false);
   type.addMethod(":call", node.func);
 }
 // ********** Code for Parameter **************
 function Parameter(definition, method) {
+  this.isInitializer = false;
+  this.definition = definition;
   this.method = method;
-  this.definition = definition;
-  this.isInitializer = false;
 }
 Parameter.prototype.get$definition = function() { return this.definition; };
 Parameter.prototype.get$method = function() { return this.method; };
 Parameter.prototype.get$name = function() { return this.name; };
 Parameter.prototype.set$name = function(value) { return this.name = value; };
 Parameter.prototype.get$type = function() { return this.type; };
 Parameter.prototype.get$isInitializer = function() { return this.isInitializer; };
 Parameter.prototype.get$value = function() { return this.value; };
 Parameter.prototype.set$value = function(value) { return this.value = value; };
 Parameter.prototype.resolve = function() {
@@ skipping 66 matching lines @@
 }
 TypeMember.prototype._set = function(context, node, target, value) {
   $globals.world.error("cannot set type", node.span);
 }
 TypeMember.prototype.invoke = function(context, node, target, args) {
   $globals.world.error("cannot invoke type", node.span);
 }
 // ********** Code for FieldMember **************
 $inherits(FieldMember, Member);
 function FieldMember(name, declaringType, definition, value, isNative) {
+  this._computing = false;
+  this.definition = definition;
+  this.value = value;
   this.isNative = isNative;
-  this.definition = definition;
-  this._computing = false;
-  this.value = value;
   Member.call(this, name, declaringType);
 }
 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.get$isStatic = function() { return this.isStatic; };
 FieldMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 FieldMember.prototype.get$isFinal = function() { return this.isFinal; };
 FieldMember.prototype.get$isNative = function() { return this.isNative; };
 FieldMember.prototype.override = function(other) {
@@ skipping 238 matching lines @@
     }
     if (!this.setter.returnType.get$isVoid() && this.setter.definition.returnType != null) {
       $globals.world.warning("setter methods should be void", this.setter.definition.returnType.span);
     }
   }
   if (this.declaringType.get$isClass()) this.get$library()._addMember(this);
 }
 // ********** Code for MethodMember **************
 $inherits(MethodMember, Member);
 function MethodMember(name, declaringType, definition) {
+  this.isStatic = false;
+  this.isAbstract = false;
+  this.isConst = false;
+  this.isFactory = false;
+  this._provideOptionalParamInfo = false;
+  this.definition = definition;
   this.isLambda = false;
-  this._provideOptionalParamInfo = false;
-  this.isFactory = false;
-  this.definition = definition;
-  this.isConst = false;
-  this.isAbstract = false;
-  this.isStatic = false;
   Member.call(this, name, declaringType);
 }
 MethodMember.lambda$ctor = function(name, declaringType, definition) {
+  this.isStatic = false;
+  this.isAbstract = false;
+  this.isConst = false;
+  this.isFactory = false;
+  this._provideOptionalParamInfo = false;
+  this.definition = definition;
   this.isLambda = true;
-  this._provideOptionalParamInfo = false;
-  this.isFactory = false;
-  this.definition = definition;
-  this.isConst = false;
-  this.isAbstract = false;
-  this.isStatic = false;
   Member.call(this, name, declaringType);
 }
 MethodMember.lambda$ctor.prototype = MethodMember.prototype;
 MethodMember.prototype.get$definition = function() { return this.definition; };
 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.set$_methodData = function(value) { return this._methodData = value; };
 MethodMember.prototype.get$isStatic = function() { return this.isStatic; };
@@ skipping 542 matching lines @@
   );
 }
 FactoryMap.prototype.isEmpty = function() {
   return this.factories.getValues().every((function (constructors) {
     return constructors.isEmpty();
   })
   );
 }
 // ********** Code for MemberSet **************
 function MemberSet(member, isVar) {
+  this._preparedForSet = false;
+  this.name = member.name;
+  this.members = [member];
   this.jsname = member.get$jsname();
-  this.name = member.name;
-  this._preparedForSet = false;
   this.isVar = isVar;
-  this.members = [member];
 }
 MemberSet.prototype.get$name = function() { return this.name; };
 MemberSet.prototype.get$members = function() { return this.members; };
 MemberSet.prototype.get$isVar = function() { return this.isVar; };
 MemberSet.prototype.get$jsname = function() { return this.jsname; };
 MemberSet.prototype.set$jsname = function(value) { return this.jsname = value; };
 MemberSet.prototype.toString = function() {
   return ("" + this.name + ":" + this.members.get$length());
 }
 MemberSet.prototype.add = function(member) {
@@ skipping 202 matching lines @@
         this.returnType = $globals.world.varType;
       }
     }
   }
   if (this.returnType == null) {
     this.returnType = $globals.world.varType;
   }
 }
 // ********** Code for MethodCallData **************
 function MethodCallData(data, method) {
+  this.data = data;
   this.method = method;
-  this.data = data;
 }
 MethodCallData.prototype.get$method = function() { return this.method; };
 MethodCallData.prototype.get$_methodGenerator = function() { return this._methodGenerator; };
 MethodCallData.prototype.matches = function(other) {
   return $eq$(this.method, other.method);
 }
 MethodCallData.prototype.run = function() {
   if (null != this._methodGenerator) return;
   this._methodGenerator = new MethodGenerator(this.method, this.data.context);
   this._methodGenerator.run();
 }
 MethodCallData.prototype.run$0 = MethodCallData.prototype.run;
 // ********** Code for MethodData **************
 function MethodData(baseMethod, context) {
   this.needsTypeParams = false;
-  this._calls = [];
   this.baseMethod = baseMethod;
   this.context = context;
+  this._calls = [];
   this.body = this.baseMethod.definition.body;
   if (this.baseMethod.get$isConstructor()) {
     this.needsTypeParams = true;
   }
 }
 MethodData.prototype.get$body = function() { return this.body; };
 MethodData.prototype.analyze = function() {
   var ma = new MethodAnalyzer(this.baseMethod, this.body);
   ma.analyze$1(this.context);
 }
@@ skipping 64 matching lines @@
   lambdaGen.run();
   if (this.baseMethod.name != "") {
     lambdaGen._popBlock(this.baseMethod.definition);
   }
   var writer = new CodeWriter();
   lambdaGen.writeDefinition(writer, node);
   return new Value(this.baseMethod.get$functionType(), writer.get$text(), this.baseMethod.definition.span);
 }
 // ********** Code for Token **************
 function Token(kind, source, start, end) {
+  this.kind = kind;
+  this.source = source;
+  this.start = start;
   this.end = end;
-  this.kind = kind;
-  this.start = start;
-  this.source = source;
 }
 Token.prototype.get$kind = function() { return this.kind; };
 Token.prototype.get$start = function() { return this.start; };
 Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
 }
 Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
   if ($ne$(kindText, actualText)) {
@@ skipping 20 matching lines @@
 LiteralToken.prototype.set$value = function(value) { return this.value = value; };
 // ********** Code for ErrorToken **************
 $inherits(ErrorToken, Token);
 function ErrorToken(kind, source, start, end, message) {
   this.message = message;
   Token.call(this, kind, source, start, end);
 }
 ErrorToken.prototype.get$message = function() { return this.message; };
 // ********** Code for SourceFile **************
 function SourceFile(filename, _text) {
+  this.filename = filename;
   this._text = _text;
-  this.filename = filename;
 }
 SourceFile.prototype.get$filename = function() { return this.filename; };
 SourceFile.prototype.get$text = function() {
   return this._text;
 }
 SourceFile.prototype.get$lineStarts = function() {
   if (this._lineStarts == null) {
     var starts = [(0)];
     var index = (0);
     while ($lt$(index, this.get$text().length)) {
@@ skipping 82 matching lines @@
 }
 SourceSpan.prototype.compareTo = function(other) {
   if ($eq$(this.file, other.file)) {
     var d = this.start - other.start;
     return d == (0) ? (this.end - other.end) : d;
   }
   return this.file.compareTo(other.file);
 }
 // ********** Code for InterpStack **************
 function InterpStack(previous, quote, isMultiline) {
+  this.previous = previous;
   this.quote = quote;
   this.isMultiline = isMultiline;
   this.depth = (-1);
-  this.previous = previous;
 }
 InterpStack.prototype.set$previous = function(value) { return this.previous = value; };
 InterpStack.prototype.get$quote = function() { return this.quote; };
 InterpStack.prototype.get$isMultiline = function() { return this.isMultiline; };
 InterpStack.prototype.get$depth = function() { return this.depth; };
 InterpStack.prototype.pop = function() {
   return this.previous;
 }
 InterpStack.push = function(stack, quote, isMultiline) {
   var newStack = new InterpStack(stack, quote, isMultiline);
@@ skipping 12 matching lines @@
 }
 TokenizerHelpers.isIdentifierPart = function(c) {
   return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c) || c == (36));
 }
 TokenizerHelpers.isInterpIdentifierPart = function(c) {
   return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c));
 }
 // ********** Code for TokenizerBase **************
 $inherits(TokenizerBase, TokenizerHelpers);
 function TokenizerBase(_source, _skipWhitespace, index) {
+  this._source = _source;
+  this._skipWhitespace = _skipWhitespace;
   this._lang_index = index;
-  this._skipWhitespace = _skipWhitespace;
-  this._source = _source;
   TokenizerHelpers.call(this);
   this._text = this._source.get$text();
 }
 TokenizerBase.prototype._nextChar = function() {
   if (this._lang_index < this._text.length) {
     return this._text.charCodeAt(this._lang_index++);
   }
   else {
     return (0);
   }
@@ skipping 1781 matching lines @@
 }
 TokenKind.kindFromAssign = function(kind) {
   if (kind == (20)) return (0);
   if (kind > (20) && kind <= (32)) {
     return kind + (15);
   }
   return (-1);
 }
 // ********** Code for Parser **************
 function Parser(source, diet, throwOnIncomplete, optionalSemicolons, startOffset) {
+  this._inhibitLambda = false;
+  this._afterParensIndex = (0);
+  this._recover = false;
+  this.source = source;
+  this.diet = diet;
   this.throwOnIncomplete = throwOnIncomplete;
-  this.source = source;
   this.optionalSemicolons = optionalSemicolons;
-  this._recover = false;
-  this._inhibitLambda = false;
-  this.diet = diet;
-  this._afterParensIndex = (0);
   this.tokenizer = new Tokenizer(this.source, true, startOffset);
   this._peekToken = this.tokenizer.next();
   this._afterParens = [];
 }
 Parser.prototype.get$enableAwait = function() {
   return $globals.experimentalAwaitPhase != null;
 }
 Parser.prototype.isPrematureEndOfFile = function() {
   if (this.throwOnIncomplete && this._maybeEat((1))) {
     $throw(new IncompleteSourceException(this._previousToken));
@@ skipping 1521 matching lines @@
 function IncompleteSourceException(token) {
   this.token = token;
 }
 IncompleteSourceException.prototype.toString = function() {
   if (this.token.get$span() == null) return ("Unexpected " + this.token);
   return this.token.get$span().toMessageString(("Unexpected " + this.token));
 }
 IncompleteSourceException.prototype.toString$0 = IncompleteSourceException.prototype.toString;
 // ********** Code for DivertedTokenSource **************
 function DivertedTokenSource(tokens, parser, previousTokenizer) {
-  this.parser = parser;
   this._lang_pos = (0);
   this.tokens = tokens;
+  this.parser = parser;
   this.previousTokenizer = previousTokenizer;
 }
 DivertedTokenSource.prototype.next = function() {
   var token = this.tokens.$index(this._lang_pos);
   ++this._lang_pos;
   if (this._lang_pos == this.tokens.get$length()) {
     this.parser.tokenizer = this.previousTokenizer;
   }
   return token;
 }
@@ skipping 25 matching lines @@
   Node.call(this, span);
 }
 // ********** Code for TypeReference **************
 $inherits(TypeReference, Node);
 function TypeReference(span) {
   Node.call(this, span);
 }
 // ********** Code for DirectiveDefinition **************
 $inherits(DirectiveDefinition, Definition);
 function DirectiveDefinition(name, arguments, span) {
+  this.name = name;
   this.arguments = arguments;
-  this.name = name;
   Definition.call(this, span);
 }
 DirectiveDefinition.prototype.get$name = function() { return this.name; };
 DirectiveDefinition.prototype.set$name = function(value) { return this.name = value; };
 DirectiveDefinition.prototype.visit = function(visitor) {
   return visitor.visitDirectiveDefinition(this);
 }
 // ********** Code for TypeDefinition **************
 $inherits(TypeDefinition, Definition);
 function TypeDefinition(isClass, name, typeParameters, extendsTypes, implementsTypes, nativeType, defaultType, body, span) {
-  this.extendsTypes = extendsTypes;
   this.isClass = isClass;
   this.name = name;
+  this.typeParameters = typeParameters;
+  this.extendsTypes = extendsTypes;
+  this.implementsTypes = implementsTypes;
+  this.nativeType = nativeType;
+  this.defaultType = defaultType;
   this.body = body;
-  this.typeParameters = typeParameters;
-  this.nativeType = nativeType;
-  this.implementsTypes = implementsTypes;
-  this.defaultType = defaultType;
   Definition.call(this, span);
 }
 TypeDefinition.prototype.get$isClass = function() { return this.isClass; };
 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.get$nativeType = function() { return this.nativeType; };
 TypeDefinition.prototype.get$body = function() { return this.body; };
 TypeDefinition.prototype.visit = function(visitor) {
   return visitor.visitTypeDefinition(this);
 }
 // ********** Code for FunctionTypeDefinition **************
 $inherits(FunctionTypeDefinition, Definition);
 function FunctionTypeDefinition(func, typeParameters, span) {
+  this.func = func;
   this.typeParameters = typeParameters;
-  this.func = func;
   Definition.call(this, span);
 }
 FunctionTypeDefinition.prototype.get$func = function() { return this.func; };
 FunctionTypeDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
 FunctionTypeDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeDefinition(this);
 }
 // ********** Code for VariableDefinition **************
 $inherits(VariableDefinition, Definition);
 function VariableDefinition(modifiers, type, names, values, span) {
   this.modifiers = modifiers;
   this.type = type;
   this.names = names;
   this.values = values;
   Definition.call(this, span);
 }
 VariableDefinition.prototype.get$type = function() { return this.type; };
 VariableDefinition.prototype.get$names = function() { return this.names; };
 VariableDefinition.prototype.set$names = function(value) { return this.names = value; };
 VariableDefinition.prototype.visit = function(visitor) {
   return visitor.visitVariableDefinition(this);
 }
 // ********** Code for FunctionDefinition **************
 $inherits(FunctionDefinition, Definition);
 function FunctionDefinition(modifiers, returnType, name, formals, initializers, nativeBody, body, span) {
   this.modifiers = modifiers;
+  this.returnType = returnType;
   this.name = name;
+  this.formals = formals;
   this.initializers = initializers;
+  this.nativeBody = nativeBody;
   this.body = body;
-  this.returnType = returnType;
-  this.formals = formals;
-  this.nativeBody = nativeBody;
   Definition.call(this, span);
 }
 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.get$initializers = function() { return this.initializers; };
 FunctionDefinition.prototype.get$body = function() { return this.body; };
 FunctionDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
@@ skipping 46 matching lines @@
   Statement.call(this, span);
 }
 ContinueStatement.prototype.get$label = function() { return this.label; };
 ContinueStatement.prototype.visit = function(visitor) {
   return visitor.visitContinueStatement(this);
 }
 // ********** Code for IfStatement **************
 $inherits(IfStatement, Statement);
 function IfStatement(test, trueBranch, falseBranch, span) {
   this.test = test;
+  this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
-  this.trueBranch = trueBranch;
   Statement.call(this, span);
 }
 IfStatement.prototype.visit = function(visitor) {
   return visitor.visitIfStatement(this);
 }
 // ********** Code for WhileStatement **************
 $inherits(WhileStatement, Statement);
 function WhileStatement(test, body, span) {
+  this.test = test;
   this.body = body;
-  this.test = test;
   Statement.call(this, span);
 }
 WhileStatement.prototype.get$body = function() { return this.body; };
 WhileStatement.prototype.visit = function(visitor) {
   return visitor.visitWhileStatement(this);
 }
 // ********** Code for DoStatement **************
 $inherits(DoStatement, Statement);
 function DoStatement(body, test, span) {
   this.body = body;
   this.test = test;
   Statement.call(this, span);
 }
 DoStatement.prototype.get$body = function() { return this.body; };
 DoStatement.prototype.visit = function(visitor) {
   return visitor.visitDoStatement(this);
 }
 // ********** Code for ForStatement **************
 $inherits(ForStatement, Statement);
 function ForStatement(init, test, step, body, span) {
-  this.body = body;
+  this.init = init;
   this.test = test;
   this.step = step;
-  this.init = init;
+  this.body = body;
   Statement.call(this, span);
 }
 ForStatement.prototype.get$body = function() { return this.body; };
 ForStatement.prototype.visit = function(visitor) {
   return visitor.visitForStatement(this);
 }
 // ********** Code for ForInStatement **************
 $inherits(ForInStatement, Statement);
 function ForInStatement(item, list, body, span) {
-  this.body = body;
   this.item = item;
   this.list = list;
+  this.body = body;
   Statement.call(this, span);
 }
 ForInStatement.prototype.get$body = function() { return this.body; };
 ForInStatement.prototype.visit = function(visitor) {
   return visitor.visitForInStatement(this);
 }
 // ********** Code for TryStatement **************
 $inherits(TryStatement, Statement);
 function TryStatement(body, catches, finallyBlock, span) {
   this.body = body;
+  this.catches = catches;
   this.finallyBlock = finallyBlock;
-  this.catches = catches;
   Statement.call(this, span);
 }
 TryStatement.prototype.get$body = function() { return this.body; };
 TryStatement.prototype.visit = function(visitor) {
   return visitor.visitTryStatement(this);
 }
 // ********** Code for SwitchStatement **************
 $inherits(SwitchStatement, Statement);
 function SwitchStatement(test, cases, span) {
   this.test = test;
@@ skipping 10 matching lines @@
   this.body = body;
   Statement.call(this, span);
 }
 BlockStatement.prototype.get$body = function() { return this.body; };
 BlockStatement.prototype.visit = function(visitor) {
   return visitor.visitBlockStatement(this);
 }
 // ********** Code for LabeledStatement **************
 $inherits(LabeledStatement, Statement);
 function LabeledStatement(name, body, span) {
+  this.name = name;
   this.body = body;
-  this.name = name;
   Statement.call(this, span);
 }
 LabeledStatement.prototype.get$name = function() { return this.name; };
 LabeledStatement.prototype.set$name = function(value) { return this.name = value; };
 LabeledStatement.prototype.get$body = function() { return this.body; };
 LabeledStatement.prototype.visit = function(visitor) {
   return visitor.visitLabeledStatement(this);
 }
 // ********** Code for ExpressionStatement **************
 $inherits(ExpressionStatement, Statement);
@@ skipping 47 matching lines @@
   this.target = target;
   this.index = index;
   Expression.call(this, span);
 }
 IndexExpression.prototype.visit = function(visitor) {
   return visitor.visitIndexExpression(this);
 }
 // ********** Code for BinaryExpression **************
 $inherits(BinaryExpression, Expression);
 function BinaryExpression(op, x, y, span) {
+  this.op = op;
+  this.x = x;
   this.y = y;
-  this.x = x;
-  this.op = op;
   Expression.call(this, span);
 }
 BinaryExpression.prototype.get$op = function() { return this.op; };
 BinaryExpression.prototype.get$x = function() { return this.x; };
 BinaryExpression.prototype.get$y = function() { return this.y; };
 BinaryExpression.prototype.visit = function(visitor) {
   return visitor.visitBinaryExpression$1(this);
 }
 // ********** Code for UnaryExpression **************
 $inherits(UnaryExpression, Expression);
 function UnaryExpression(op, self, span) {
+  this.op = op;
   this.self = self;
-  this.op = op;
   Expression.call(this, span);
 }
 UnaryExpression.prototype.get$op = function() { return this.op; };
 UnaryExpression.prototype.get$self = function() { return this.self; };
 UnaryExpression.prototype.visit = function(visitor) {
   return visitor.visitUnaryExpression(this);
 }
 // ********** Code for PostfixExpression **************
 $inherits(PostfixExpression, Expression);
 function PostfixExpression(body, op, span) {
   this.body = body;
   this.op = op;
   Expression.call(this, span);
 }
 PostfixExpression.prototype.get$body = function() { return this.body; };
 PostfixExpression.prototype.get$op = function() { return this.op; };
 PostfixExpression.prototype.visit = function(visitor) {
   return visitor.visitPostfixExpression$1(this);
 }
 // ********** Code for NewExpression **************
 $inherits(NewExpression, Expression);
 function NewExpression(isConst, type, name, arguments, span) {
+  this.isConst = isConst;
+  this.type = type;
+  this.name = name;
   this.arguments = arguments;
-  this.name = name;
-  this.type = type;
-  this.isConst = isConst;
   Expression.call(this, span);
 }
 NewExpression.prototype.get$isConst = function() { return this.isConst; };
 NewExpression.prototype.get$type = function() { return this.type; };
 NewExpression.prototype.get$name = function() { return this.name; };
 NewExpression.prototype.set$name = function(value) { return this.name = value; };
 NewExpression.prototype.visit = function(visitor) {
   return visitor.visitNewExpression(this);
 }
 // ********** Code for ListExpression **************
 $inherits(ListExpression, Expression);
 function ListExpression(isConst, itemType, values, span) {
+  this.isConst = isConst;
   this.itemType = itemType;
-  this.isConst = isConst;
   this.values = values;
   Expression.call(this, span);
 }
 ListExpression.prototype.get$isConst = function() { return this.isConst; };
 ListExpression.prototype.visit = function(visitor) {
   return visitor.visitListExpression(this);
 }
 // ********** Code for MapExpression **************
 $inherits(MapExpression, Expression);
 function MapExpression(isConst, keyType, valueType, items, span) {
+  this.isConst = isConst;
   this.keyType = keyType;
   this.valueType = valueType;
   this.items = items;
-  this.isConst = isConst;
   Expression.call(this, span);
 }
 MapExpression.prototype.get$isConst = function() { return this.isConst; };
 MapExpression.prototype.visit = function(visitor) {
   return visitor.visitMapExpression(this);
 }
 // ********** Code for ConditionalExpression **************
 $inherits(ConditionalExpression, Expression);
 function ConditionalExpression(test, trueBranch, falseBranch, span) {
   this.test = test;
+  this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
-  this.trueBranch = trueBranch;
   Expression.call(this, span);
 }
 ConditionalExpression.prototype.visit = function(visitor) {
   return visitor.visitConditionalExpression(this);
 }
 // ********** Code for IsExpression **************
 $inherits(IsExpression, Expression);
 function IsExpression(isTrue, x, type, span) {
   this.isTrue = isTrue;
   this.x = x;
@@ skipping 100 matching lines @@
   this.type = type;
   TypeReference.call(this, span);
 }
 SimpleTypeReference.prototype.get$type = function() { return this.type; };
 SimpleTypeReference.prototype.visit = function(visitor) {
   return visitor.visitSimpleTypeReference(this);
 }
 // ********** Code for NameTypeReference **************
 $inherits(NameTypeReference, TypeReference);
 function NameTypeReference(isFinal, name, names, span) {
+  this.isFinal = isFinal;
   this.name = name;
   this.names = names;
-  this.isFinal = isFinal;
   TypeReference.call(this, span);
 }
 NameTypeReference.prototype.get$isFinal = function() { return this.isFinal; };
 NameTypeReference.prototype.get$name = function() { return this.name; };
 NameTypeReference.prototype.set$name = function(value) { return this.name = value; };
 NameTypeReference.prototype.get$names = function() { return this.names; };
 NameTypeReference.prototype.set$names = function(value) { return this.names = value; };
 NameTypeReference.prototype.visit = function(visitor) {
   return visitor.visitNameTypeReference(this);
 }
 // ********** Code for GenericTypeReference **************
 $inherits(GenericTypeReference, TypeReference);
 function GenericTypeReference(baseType, typeArguments, depth, span) {
-  this.depth = depth;
   this.baseType = baseType;
   this.typeArguments = typeArguments;
+  this.depth = depth;
   TypeReference.call(this, span);
 }
 GenericTypeReference.prototype.get$baseType = function() { return this.baseType; };
 GenericTypeReference.prototype.get$typeArguments = function() { return this.typeArguments; };
 GenericTypeReference.prototype.get$depth = function() { return this.depth; };
 GenericTypeReference.prototype.visit = function(visitor) {
   return visitor.visitGenericTypeReference(this);
 }
 // ********** Code for FunctionTypeReference **************
 $inherits(FunctionTypeReference, TypeReference);
 function FunctionTypeReference(isFinal, func, span) {
+  this.isFinal = isFinal;
   this.func = func;
-  this.isFinal = isFinal;
   TypeReference.call(this, span);
 }
 FunctionTypeReference.prototype.get$isFinal = function() { return this.isFinal; };
 FunctionTypeReference.prototype.get$func = function() { return this.func; };
 FunctionTypeReference.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeReference(this);
 }
 // ********** Code for DefaultTypeReference **************
 $inherits(DefaultTypeReference, TypeReference);
 function DefaultTypeReference(oldFactory, baseType, typeParameters, span) {
-  this.typeParameters = typeParameters;
   this.oldFactory = oldFactory;
   this.baseType = baseType;
+  this.typeParameters = typeParameters;
   TypeReference.call(this, span);
 }
 DefaultTypeReference.prototype.get$baseType = function() { return this.baseType; };
 DefaultTypeReference.prototype.get$typeParameters = function() { return this.typeParameters; };
 DefaultTypeReference.prototype.visit = function(visitor) {
   return visitor.visitDefaultTypeReference(this);
 }
 // ********** Code for ArgumentNode **************
 $inherits(ArgumentNode, Node);
 function ArgumentNode(label, value, span) {
   this.label = label;
   this.value = value;
   Node.call(this, span);
 }
 ArgumentNode.prototype.get$label = function() { return this.label; };
 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);
 }
 // ********** Code for FormalNode **************
 $inherits(FormalNode, Node);
 function FormalNode(isThis, isRest, type, name, value, span) {
+  this.isThis = isThis;
+  this.isRest = isRest;
+  this.type = type;
   this.name = name;
-  this.isThis = isThis;
-  this.type = type;
-  this.isRest = isRest;
   this.value = value;
   Node.call(this, span);
 }
 FormalNode.prototype.get$type = function() { return this.type; };
 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);
 }
 // ********** Code for CatchNode **************
 $inherits(CatchNode, Node);
 function CatchNode(exception, trace, body, span) {
-  this.body = body;
   this.exception = exception;
   this.trace = trace;
+  this.body = body;
   Node.call(this, span);
 }
 CatchNode.prototype.get$exception = function() { return this.exception; };
 CatchNode.prototype.get$trace = function() { return this.trace; };
 CatchNode.prototype.get$body = function() { return this.body; };
 CatchNode.prototype.visit = function(visitor) {
   return visitor.visitCatchNode(this);
 }
 // ********** Code for CaseNode **************
 $inherits(CaseNode, Node);
 function CaseNode(label, cases, statements, span) {
   this.label = label;
+  this.cases = cases;
   this.statements = statements;
-  this.cases = cases;
   Node.call(this, span);
 }
 CaseNode.prototype.get$label = function() { return this.label; };
 CaseNode.prototype.get$cases = function() { return this.cases; };
 CaseNode.prototype.get$statements = function() { return this.statements; };
 CaseNode.prototype.visit = function(visitor) {
   return visitor.visitCaseNode(this);
 }
 // ********** Code for TypeParameter **************
 $inherits(TypeParameter, Node);
 function TypeParameter(name, extendsType, span) {
+  this.name = name;
   this.extendsType = extendsType;
-  this.name = name;
   Node.call(this, span);
 }
 TypeParameter.prototype.get$name = function() { return this.name; };
 TypeParameter.prototype.set$name = function(value) { return this.name = value; };
 TypeParameter.prototype.get$extendsType = function() { return this.extendsType; };
 TypeParameter.prototype.visit = function(visitor) {
   return visitor.visitTypeParameter(this);
 }
 // ********** Code for Identifier **************
 $inherits(Identifier, Node);
 function Identifier(name, span) {
   this.name = name;
   Node.call(this, span);
 }
 Identifier.prototype.get$name = function() { return this.name; };
 Identifier.prototype.set$name = function(value) { return this.name = value; };
 Identifier.prototype.visit = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 // ********** Code for DeclaredIdentifier **************
 $inherits(DeclaredIdentifier, Expression);
 function DeclaredIdentifier(type, name, isFinal, span) {
+  this.type = type;
   this.name = name;
-  this.type = type;
   this.isFinal = isFinal;
   Expression.call(this, span);
 }
 DeclaredIdentifier.prototype.get$type = function() { return this.type; };
 DeclaredIdentifier.prototype.get$name = function() { return this.name; };
 DeclaredIdentifier.prototype.set$name = function(value) { return this.name = value; };
 DeclaredIdentifier.prototype.get$isFinal = function() { return this.isFinal; };
 DeclaredIdentifier.prototype.visit = function(visitor) {
   return visitor.visitDeclaredIdentifier(this);
 }
 // ********** Code for Type **************
 $inherits(Type, Element);
 function Type(name) {
   this.isTested = false;
-  this._foundMembers = new HashMapImplementation();
   this.isChecked = false;
   this.isWritten = false;
+  this._foundMembers = new HashMapImplementation();
   this.varStubs = new HashMapImplementation();
   Element.call(this, name, null);
 }
 Type.prototype.get$typeCheckCode = function() { return this.typeCheckCode; };
 Type.prototype.get$varStubs = function() { return this.varStubs; };
 Type.prototype.markUsed = function() {
 
 }
 Type.prototype.get$typeMember = function() {
   if (this._typeMember == null) {
@@ skipping 413 matching lines @@
 NonNullableType.prototype.get$parent = function() {
   return this.type.get$parent();
 }
 NonNullableType.prototype.get$isNative = function() {
   return this.type.get$isNative();
 }
 // ********** Code for DefinedType **************
 $inherits(DefinedType, Type);
 function DefinedType(name, library, definition, isClass) {
   this.isUsed = false;
-  this.directSubtypes = new HashSetImplementation_Type();
   this.isNative = false;
   this.library = library;
   this.isClass = isClass;
+  this.directSubtypes = new HashSetImplementation_Type();
   this.constructors = new HashMapImplementation();
+  this.members = new HashMapImplementation();
   this.factories = new FactoryMap();
-  this.members = new HashMapImplementation();
   Type.call(this, name);
   this.setDefinition(definition);
 }
 DefinedType.prototype.get$definition = function() { return this.definition; };
 DefinedType.prototype.get$library = function() { return this.library; };
 DefinedType.prototype.get$isClass = function() { return this.isClass; };
 DefinedType.prototype.get$parent = function() {
   return this._parent;
 }
 DefinedType.prototype.set$parent = function(p) {
@@ skipping 487 matching lines @@
   var stub = this.varStubs.$index(name);
   if ($eq$(stub)) {
     stub = new VarFunctionStub(name, args);
     this.varStubs.$setindex(name, stub);
   }
   return stub;
 }
 // ********** Code for NativeType **************
 function NativeType(name) {
   this.isConstructorHidden = false;
+  this.isJsGlobalObject = false;
   this.isSingleton = false;
-  this.isJsGlobalObject = false;
   this.name = name;
   while (true) {
     if (this.name.startsWith("@")) {
       this.name = this.name.substring((1));
       this.isJsGlobalObject = true;
     }
     else if (this.name.startsWith("*")) {
       this.name = this.name.substring((1));
       this.isConstructorHidden = true;
     }
@@ skipping 84 matching lines @@
 // ********** Code for CopyOnWriteMap_dart_core_String$VariableValue **************
 $inherits(CopyOnWriteMap_dart_core_String$VariableValue, CopyOnWriteMap);
 function CopyOnWriteMap_dart_core_String$VariableValue() {
   this._lang_map = new _SharedBackingMap_dart_core_String$VariableValue();
 }
 CopyOnWriteMap_dart_core_String$VariableValue.prototype.is$Map = function(){return true};
 CopyOnWriteMap_dart_core_String$VariableValue.prototype.remove$1 = CopyOnWriteMap_dart_core_String$VariableValue.prototype.remove;
 // ********** Code for Value **************
 function Value(type, code, span) {
   this.type = type;
+  this.code = code;
   this.span = span;
-  this.code = code;
   if (this.get$type() == null) $globals.world.internalError("type passed as null", this.span);
 }
 Value.prototype.get$type = function() { return this.type; };
 Value.prototype.get$code = function() { return this.code; };
 Value.prototype.get$span = function() { return this.span; };
 Value.prototype.get$isType = function() {
   return false;
 }
 Value.prototype.get$isSuper = function() {
   return false;
@@ skipping 489 matching lines @@
   return this.setIndex($0, $1, $2, $3, kind, (1));
 };
 Value.prototype.setIndex$4$kind$returnKind = Value.prototype.setIndex;
 Value.prototype.set_$4$kind = function($0, $1, $2, $3, kind) {
   return this.set_($0, $1, $2, $3, kind, (1));
 };
 Value.prototype.set_$4$kind$returnKind = Value.prototype.set_;
 // ********** Code for PureStaticValue **************
 $inherits(PureStaticValue, Value);
 function PureStaticValue(type, span, isConst, isType) {
+  this.isConst = isConst;
   this.isType = isType;
-  this.isConst = isConst;
   Value.call(this, type, null, span);
 }
 PureStaticValue.prototype.get$isConst = function() { return this.isConst; };
 PureStaticValue.prototype.get$isType = function() { return this.isType; };
 PureStaticValue.prototype.getMem = function(context, name, node) {
   var member = this.get$type().getMember(name);
   if ($eq$(member)) {
     $globals.world.warning(("cannot find \"" + name + "\" on \"" + this.get$type().name + "\""), node.span);
     return null;
   }
@@ skipping 681 matching lines @@
       return new BoolValue($ne$(this.get$type(), other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 // ********** Code for ObjectValue **************
 $inherits(ObjectValue, EvaluatedValue);
 function ObjectValue(isConst, type, span) {
   this.seenNativeInitializer = false;
   this.fields = new HashMapImplementation();
+  this.fieldsInInitOrder = [];
   EvaluatedValue.call(this, isConst, type, span);
 }
 ObjectValue.prototype.get$fields = function() { return this.fields; };
+ObjectValue.prototype.get$fieldsInInitOrder = function() { return this.fieldsInInitOrder; };
 ObjectValue.prototype.get$seenNativeInitializer = function() { return this.seenNativeInitializer; };
 ObjectValue.prototype.set$seenNativeInitializer = function(value) { return this.seenNativeInitializer = value; };
 ObjectValue.prototype.get$code = function() {
   if (null == this._code) this.validateInitialized(null);
   return this._code;
 }
 ObjectValue.prototype.initFields = function() {
   var allMembers = $globals.world.gen._orderValues(this.get$type().get$genericType().getAllMembers());
   for (var $$i = allMembers.iterator(); $$i.hasNext(); ) {
     var f = $$i.next();
     if (f.get$isField() && !f.get$isStatic() && f.get$declaringType().get$isClass()) {
-      this.fields.$setindex(f, f.computeValue());
+      this._replaceField(f, f.computeValue(), true);
     }
   }
 }
 ObjectValue.prototype.setField = function(field, value, duringInit) {
   if (value.get$isConst() && (value instanceof VariableValue)) {
     value = value.get$dynamic().get$value();
   }
   var currentValue = this.fields.$index(field);
   if (this.isConst && !value.get$isConst()) {
     $globals.world.error("used of non-const value in const intializer", value.span);
   }
   if (null == currentValue) {
-    this.fields.$setindex(field, value);
+    this._replaceField(field, value, duringInit);
     if (field.get$isFinal() && !duringInit) {
       $globals.world.error("cannot initialize final fields outside of initializer", value.span);
     }
   }
   else {
     if (field.get$isFinal() && null == field.computeValue()) {
       $globals.world.error("reassignment of field not allowed", value.span, field.get$span());
     }
     else {
-      this.fields.$setindex(field, value);
+      this._replaceField(field, value, duringInit);
     }
   }
 }
+ObjectValue.prototype._replaceField = function(field, value, duringInit) {
+  if (duringInit) {
+    for (var i = (0);
+     i < this.fieldsInInitOrder.get$length(); i++) {
+      if ($eq$(this.fieldsInInitOrder.$index(i), field)) {
+        this.fieldsInInitOrder.$setindex(i);
+        break;
+      }
+    }
+    this.fieldsInInitOrder.add(field);
+  }
+  this.fields.$setindex(field, value);
+}
 ObjectValue.prototype.validateInitialized = function(span) {
   var buf = new StringBufferImpl("");
   buf.add("Object.create(");
   buf.add(("" + this.get$type().get$jsname() + ".prototype, "));
   buf.add("{");
   var addComma = false;
   var $$list = this.fields.getKeys();
   for (var $$i = $$list.iterator(); $$i.hasNext(); ) {
     var field = $$i.next();
     if (addComma) buf.add(", ");
@@ skipping 25 matching lines @@
     case (49):
 
       return new BoolValue($ne$(this.get$type(), other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 // ********** Code for GlobalValue **************
 $inherits(GlobalValue, Value);
 function GlobalValue(type, code, isConst, field, name, exp, span, deps) {
-  this.exp = exp;
   this.field = field;
   this.name = name;
+  this.exp = exp;
+  this.isConst = isConst;
   this.dependencies = [];
-  this.isConst = isConst;
   Value.call(this, type, code, span);
   for (var $$i = deps.iterator(); $$i.hasNext(); ) {
     var dep = $$i.next();
     if ((dep instanceof GlobalValue)) {
       this.dependencies.add(dep);
       this.dependencies.addAll(dep.get$dependencies());
     }
   }
 }
 GlobalValue.prototype.get$field = function() { return this.field; };
@@ skipping 35 matching lines @@
   else if (this.name != null) {
     return this.name.compareTo(other.name);
   }
   else {
     return this.field.name.compareTo(other.field.name);
   }
 }
 // ********** Code for BareValue **************
 $inherits(BareValue, Value);
 function BareValue(home, outermost, span) {
+  this.home = home;
   this.isType = outermost.get$isStatic();
-  this.home = home;
   Value.call(this, outermost.method.get$declaringType(), null, span);
 }
 BareValue.prototype.get$isType = function() { return this.isType; };
 BareValue.prototype.get$needsTemp = function() {
   return false;
 }
 BareValue.prototype._shouldBindDynamically = function() {
   return false;
 }
 BareValue.prototype.get$code = function() {
@@ skipping 57 matching lines @@
 }
 TypeValue.prototype._shouldBindDynamically = function() {
   return false;
 }
 TypeValue.prototype._tryUnion = function(right) {
   return (right instanceof TypeValue) ? this : null;
 }
 // ********** Code for VariableValue **************
 $inherits(VariableValue, Value);
 function VariableValue(staticType, code, span, isFinal, value) {
+  this.isFinal = isFinal;
   this.value = VariableValue._unwrap(value);
-  this.isFinal = isFinal;
   Value.call(this, staticType, code, span);
 }
 VariableValue.prototype.get$isFinal = function() { return this.isFinal; };
 VariableValue.prototype.get$value = function() { return this.value; };
 VariableValue._unwrap = function(v) {
   if (null == v) return null;
   if ((v instanceof VariableValue)) {
     v = v.get$dynamic().get$value();
   }
   return v;
@@ skipping 37 matching lines @@
   if (this._location != null) {
     return ("CompilerException: " + this._location.toMessageString(this._lang_message));
   }
   else {
     return ("CompilerException: " + this._lang_message);
   }
 }
 CompilerException.prototype.toString$0 = CompilerException.prototype.toString;
 // ********** Code for CounterLog **************
 function CounterLog() {
-  this.msetN = (0);
-  this.objectProtoMembers = (0);
   this.dynamicMethodCalls = (0);
   this.typeAsserts = (0);
+  this.objectProtoMembers = (0);
   this.invokeCalls = (0);
+  this.msetN = (0);
 }
 CounterLog.prototype.info = function() {
   if ($globals.options.legOnly) return;
   $globals.world.info(("Dynamically typed method calls: " + this.dynamicMethodCalls));
   $globals.world.info(("Generated type assertions: " + this.typeAsserts));
   $globals.world.info(("Members on Object.prototype: " + this.objectProtoMembers));
   $globals.world.info(("Invoke calls: " + this.invokeCalls));
   $globals.world.info(("msetN calls: " + this.msetN));
 }
 CounterLog.prototype.add = function(other) {
   this.dynamicMethodCalls = this.dynamicMethodCalls + other.dynamicMethodCalls;
   this.typeAsserts = this.typeAsserts + other.typeAsserts;
   this.objectProtoMembers = this.objectProtoMembers + other.objectProtoMembers;
   this.invokeCalls = this.invokeCalls + other.invokeCalls;
   this.msetN = this.msetN + other.msetN;
 }
 // ********** Code for World **************
 function World(files) {
+  this.errors = (0);
+  this.warnings = (0);
+  this.dartBytesRead = (0);
+  this.jsBytesWritten = (0);
+  this.seenFatal = false;
   this.files = files;
+  this.libraries = new HashMapImplementation();
+  this._todo = [];
   this._members = new HashMapImplementation();
   this._topNames = new HashMapImplementation();
-  this.warnings = (0);
-  this.seenFatal = false;
-  this.libraries = new HashMapImplementation();
-  this.dartBytesRead = (0);
-  this._todo = [];
-  this.jsBytesWritten = (0);
+  this.reader = new LibraryReader();
   this.counters = new CounterLog();
-  this.errors = (0);
-  this.reader = new LibraryReader();
 }
 World.prototype.get$functionType = function() { return this.functionType; };
 World.prototype.init = function() {
   this.corelib = new Library(this.readFile("dart:core"));
   this.libraries.$setindex("dart:core", this.corelib);
   this._todo.add(this.corelib);
   this.coreimpl = this.getOrAddLibrary("dart:coreimpl");
   this.voidType = this.corelib.addType("void", null, false);
   this.dynamicType = this.corelib.addType("Dynamic", null, false);
   this.varType = this.dynamicType;
@@ skipping 380 matching lines @@
 World.prototype.withTiming = function(name, f) {
   var sw = new StopwatchImplementation();
   sw.start();
   var result = f();
   sw.stop();
   this.info(("" + name + " in " + sw.elapsedInMs() + "msec"));
   return result;
 }
 // ********** Code for FrogOptions **************
 function FrogOptions(homedir, args, files) {
+  this.config = "dev";
   this.legOnly = false;
-  this.ignoreUnrecognizedFlags = false;
-  this.checkOnly = false;
-  this.disableBoundsChecks = false;
-  this.maxInferenceIterations = (4);
-  this.throwOnWarnings = false;
-  this.inferTypes = false;
+  this.enableAsserts = false;
+  this.enableTypeChecks = false;
   this.warningsAsErrors = false;
-  this.enableAsserts = false;
+  this.verifyImplements = false;
+  this.compileAll = false;
   this.forceDynamic = false;
   this.dietParse = false;
   this.compileOnly = false;
+  this.inferTypes = false;
+  this.checkOnly = false;
+  this.ignoreUnrecognizedFlags = false;
+  this.disableBoundsChecks = false;
+  this.throwOnErrors = false;
+  this.throwOnWarnings = false;
+  this.throwOnFatal = false;
+  this.showInfo = false;
   this.showWarnings = true;
-  this.throwOnFatal = false;
-  this.config = "dev";
-  this.verifyImplements = false;
-  this.enableTypeChecks = false;
-  this.showInfo = false;
   this.useColors = true;
-  this.compileAll = false;
-  this.throwOnErrors = false;
+  this.maxInferenceIterations = (4);
   if ($eq$(this.config, "dev")) {
     this.libDir = joinPaths(homedir, "/lib");
   }
   else if ($eq$(this.config, "sdk")) {
     this.libDir = joinPaths(homedir, "/../lib");
   }
   else {
     $globals.world.error(("Invalid configuration " + this.config));
     $throw("Invalid configuration");
   }
@@ skipping 132 matching lines @@
 
       this.disableBoundsChecks = true;
       return true;
 
   }
   return false;
 }
 // ********** Code for LibraryReader **************
 function LibraryReader() {
   if ($eq$($globals.options.config, "dev")) {
-    this._specialLibs = _map(["dart:core", joinPaths($globals.options.libDir, "corelib.dart"), "dart:coreimpl", joinPaths($globals.options.libDir, "corelib_impl.dart"), "dart:html", joinPaths($globals.options.libDir, "../../client/html/frog/html_frog.dart"), "dart:dom", joinPaths($globals.options.libDir, "../../client/dom/frog/dom_frog.dart"), "dart:json", joinPaths($globals.options.libDir, "../../lib/json/json_frog.dart"), "dart:isolate", joinPaths($globals.options.libDir, "../../lib/isolate/isolate_frog.dart")]);
+    this._specialLibs = _map(["dart:core", joinPaths($globals.options.libDir, "corelib.dart"), "dart:coreimpl", joinPaths($globals.options.libDir, "corelib_impl.dart"), "dart:html", joinPaths($globals.options.libDir, "../../client/html/frog/html_frog.dart"), "dart:dom", joinPaths($globals.options.libDir, "../../client/dom/frog/dom_frog.dart"), "dart:json", joinPaths($globals.options.libDir, "../../lib/json/json_frog.dart"), "dart:io", joinPaths($globals.options.libDir, "../leg/lib/io.dart"), "dart:isolate", joinPaths($globals.options.libDir, "../../lib/isolate/isolate_frog.dart"), "dart:uri", joinPaths($globals.options.libDir, "../../lib/uri/uri.dart"), "dart:utf", joinPaths($globals.options.libDir, "../../lib/utf/utf.dart")]);
   }
   else if ($eq$($globals.options.config, "sdk")) {
-    this._specialLibs = _map(["dart:core", joinPaths($globals.options.libDir, "core/core_frog.dart"), "dart:coreimpl", joinPaths($globals.options.libDir, "coreimpl/coreimpl_frog.dart"), "dart:html", joinPaths($globals.options.libDir, "html/html_frog.dart"), "dart:dom", joinPaths($globals.options.libDir, "dom/frog/dom_frog.dart"), "dart:json", joinPaths($globals.options.libDir, "json/json_frog.dart"), "dart:isolate", joinPaths($globals.options.libDir, "isolate/isolate_frog.dart")]);
+    this._specialLibs = _map(["dart:core", joinPaths($globals.options.libDir, "core/core_frog.dart"), "dart:coreimpl", joinPaths($globals.options.libDir, "coreimpl/coreimpl_frog.dart"), "dart:html", joinPaths($globals.options.libDir, "html/html_frog.dart"), "dart:dom", joinPaths($globals.options.libDir, "dom/frog/dom_frog.dart"), "dart:isolate", joinPaths($globals.options.libDir, "isolate/isolate_frog.dart"), "dart:json", joinPaths($globals.options.libDir, "json/json_frog.dart"), "dart:uri", joinPaths($globals.options.libDir, "uri/uri.dart"), "dart:utf", joinPaths($globals.options.libDir, "utf/utf.dart")]);
   }
   else {
     $globals.world.error(("Invalid configuration " + $globals.options.config));
   }
 }
 LibraryReader.prototype.readFile = function(fullname) {
   var filename = this._specialLibs.$index(fullname);
   if ($eq$(filename)) {
     filename = fullname;
   }
@@ skipping 58 matching lines @@
   var named = Strings.join(this.args.getNames(), "\", \"");
   var argsCode = this.args.getCode();
   w.enterBlock(("Function.prototype." + this.name + " = function(" + argsCode + ") {"));
   w.writeln(("this." + this.name + " = this._genStub(" + this.args.get$length() + ", [\"" + named + "\"]);"));
   w.writeln(("return this." + this.name + "(" + argsCode + ");"));
   w.exitBlock("}");
 }
 // ********** Code for VarMethodStub **************
 $inherits(VarMethodStub, VarMember);
 function VarMethodStub(name, member, args, body) {
-  this.body = body;
   this.member = member;
   this.args = args;
+  this.body = body;
   VarMember.call(this, name);
 }
 VarMethodStub.prototype.get$body = function() { return this.body; };
 VarMethodStub.prototype.get$isHidden = function() {
   return this.member != null ? this.member.declaringType.get$isHiddenNativeType() : false;
 }
 VarMethodStub.prototype.get$returnType = function() {
   return this.member != null ? this.member.get$returnType() : $globals.world.varType;
 }
 VarMethodStub.prototype.get$declaringType = function() {
@@ skipping 47 matching lines @@
     }
     return method.namesInHomePositions(args);
   }
   else {
     return false;
   }
 }
 // ********** Code for VarMethodSet **************
 $inherits(VarMethodSet, VarMember);
 function VarMethodSet(baseName, name, members, callArgs, returnType) {
-  this.args = callArgs.toCallStubArgs();
   this.invoked = false;
   this.baseName = baseName;
   this.members = members;
   this.returnType = returnType;
+  this.args = callArgs.toCallStubArgs();
   VarMember.call(this, name);
 }
 VarMethodSet.prototype.get$members = function() { return this.members; };
 VarMethodSet.prototype.get$returnType = function() { return this.returnType; };
 VarMethodSet.prototype.invoke = function(context, node, target, args) {
   this._invokeMembers(context, node);
   return VarMember.prototype.invoke.call(this, context, node, target, args);
 }
 VarMethodSet.prototype._invokeMembers = function(context, node) {
   if (this.invoked) return;
@@ skipping 164 matching lines @@
 var const$0002 = Object.create(EmptyQueueException.prototype, {});
 var const$0006 = Object.create(IllegalAccessException.prototype, {});
 var const$0007 = ImmutableList.ImmutableList$from$factory([]);
 var const$0009 = new JSSyntaxRegExp("^[a-zA-Z]:/");
 var const$0010 = ImmutableList.ImmutableList$from$factory(["__PROTO__", "prototype", "constructor"]);
 var const$0011 = ImmutableList.ImmutableList$from$factory(["NaN", "Infinity", "undefined", "eval", "parseInt", "parseFloat", "isNan", "isFinite", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "Object", "Function", "Array", "String", "Boolean", "Number", "Date", "RegExp", "Error", "EvalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError", "Math", "arguments", "escape", "unescape", "applicationCache", "closed", "Components", "content", "controllers", "crypto", "defaultStatus", "dialogArguments", "directories", "document", "frameElement", "frames", "fullScreen", "globalStorage", "history", "innerHeight", "innerWidth", "length", "location", "locationbar", "localStorage", "menubar", "mozInnerScreenX", "mozInnerScreenY", "mozScreenPixelsPerCssPixel", "name", "navigator", "opener", "outerHeight", "outerWidth", "pageXOffset", "pageYOffset", "parent", "personalbar", "pkcs11", "returnValue", "screen", "scrollbars", "scrollMaxX", "scrollMaxY", "self", "sessionStorage", "sidebar", "status", "statusbar", "toolbar", "top", "window", "alert", "addEventListener", "atob", "back", "blur", "btoa", "captureEvents", "clearInterval", "clearTimeout", "close", "confirm", "disableExternalCapture", "dispatchEvent", "dump", "enableExternalCapture", "escape", "find", "focus", "forward", "GeckoActiveXObject", "getAttention", "getAttentionWithCycleCount", "getComputedStyle", "getSelection", "home", "maximize", "minimize", "moveBy", "moveTo", "open", "openDialog", "postMessage", "print", "prompt", "QueryInterface", "releaseEvents", "removeEventListener", "resizeBy", "resizeTo", "restore", "routeEvent", "scroll", "scrollBy", "scrollByLines", "scrollByPages", "scrollTo", "setInterval", "setResizeable", "setTimeout", "showModalDialog", "sizeToContent", "stop", "uuescape", "updateCommands", "XPCNativeWrapper", "XPCSafeJSOjbectWrapper", "onabort", "onbeforeunload", "onchange", "onclick", "onclose", "oncontextmenu", "ondragdrop", "onerror", "onfocus", "onhashchange", "onkeydown", "onkeypress", "onkeyup", "onload", "onmousedown", "onmousemove", "onmouseout", "onmouseover", "onmouseup", "onmozorientation", "onpaint", "onreset", "onresize", "onscroll", "onselect", "onsubmit", "onunload", "ontouchcancel", "ontouchend", "ontouchmove", "ontouchstart", "ongesturestart", "ongesturechange", "ongestureend", "uneval", "getPrototypeOf", "let", "yield", "abstract", "int", "short", "boolean", "interface", "static", "byte", "long", "char", "final", "native", "synchronized", "float", "package", "throws", "goto", "private", "transient", "implements", "protected", "volatile", "double", "public", "attachEvent", "clientInformation", "clipboardData", "createPopup", "dialogHeight", "dialogLeft", "dialogTop", "dialogWidth", "onafterprint", "onbeforedeactivate", "onbeforeprint", "oncontrolselect", "ondeactivate", "onhelp", "onresizeend", "event", "external", "Debug", "Enumerator", "Global", "Image", "ActiveXObject", "VBArray", "Components", "toString", "getClass", "constructor", "prototype", "valueOf", "Anchor", "Applet", "Attr", "Canvas", "CanvasGradient", "CanvasPattern", "CanvasRenderingContext2D", "CDATASection", "CharacterData", "Comment", "CSS2Properties", "CSSRule", "CSSStyleSheet", "Document", "DocumentFragment", "DocumentType", "DOMException", "DOMImplementation", "DOMParser", "Element", "Event", "ExternalInterface", "FlashPlayer", "Form", "Frame", "History", "HTMLCollection", "HTMLDocument", "HTMLElement", "IFrame", "Image", "Input", "JSObject", "KeyEvent", "Link", "Location", "MimeType", "MouseEvent", "Navigator", "Node", "NodeList", "Option", "Plugin", "ProcessingInstruction", "Range", "RangeException", "Screen", "Select", "Table", "TableCell", "TableRow", "TableSelection", "Text", "TextArea", "UIEvent", "Window", "XMLHttpRequest", "XMLSerializer", "XPathException", "XPathResult", "XSLTProcessor", "java", "Packages", "netscape", "sun", "JavaObject", "JavaClass", "JavaArray", "JavaMember", "$wnd", "$doc", "$entry", "$moduleName", "$moduleBase", "$gwt_version", "$sessionId", "$stack", "$stackDepth", "$location", "call"]);
 var const$0012 = ImmutableList.ImmutableList$from$factory(["break", "delete", "function", "return", "typeof", "case", "do", "if", "switch", "var", "catch", "else", "in", "this", "void", "continue", "false", "instanceof", "throw", "while", "debugger", "finally", "new", "true", "with", "default", "for", "null", "try", "abstract", "double", "goto", "native", "static", "boolean", "enum", "implements", "package", "super", "byte", "export", "import", "private", "synchronized", "char", "extends", "int", "protected", "throws", "class", "final", "interface", "public", "transient", "const", "float", "long", "short", "volatile"]);
 var $globals = {};
 $static_init();
 main();