Fix bug 578

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 323 matching lines @@
 };
 Object.prototype.contains$1 = function($0) {
   return this.noSuchMethod("contains", [$0]);
 };
 Object.prototype.convertTo$3 = function($0, $1, $2) {
   return this.noSuchMethod("convertTo", [$0, $1, $2]);
 };
 Object.prototype.convertTo$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("convertTo", [$0, $1, $2, $3]);
 };
-Object.prototype.copyWithNewType$1 = function($0) {
-  return this.noSuchMethod("copyWithNewType", [$0]);
+Object.prototype.copyWithNewType$2 = function($0, $1) {
+  return this.noSuchMethod("copyWithNewType", [$0, $1]);
 };
 Object.prototype.dataEquals$1 = function($0) {
   return this.noSuchMethod("dataEquals", [$0]);
 };
 Object.prototype.endArguments$3 = function($0, $1, $2) {
   return this.noSuchMethod("endArguments", [$0, $1, $2]);
 };
 Object.prototype.endBlock$3 = function($0, $1, $2) {
   return this.noSuchMethod("endBlock", [$0, $1, $2]);
 };
@@ skipping 296 matching lines @@
 };
 Object.prototype.replaceFirst$2 = function($0, $1) {
   return this.noSuchMethod("replaceFirst", [$0, $1]);
 };
 Object.prototype.resolve$0 = function() {
   return this.noSuchMethod("resolve", []);
 };
 Object.prototype.resolve$1 = function($0) {
   return this.noSuchMethod("resolve", [$0]);
 };
-Object.prototype.resolve$2 = function($0, $1) {
-  return this.noSuchMethod("resolve", [$0, $1]);
-};
 Object.prototype.resolveMember$1 = function($0) {
   return this.noSuchMethod("resolveMember", [$0]);
 };
 Object.prototype.resolveTypeParams$1 = function($0) {
   return this.noSuchMethod("resolveTypeParams", [$0]);
 };
 Object.prototype.setDefinition$1 = function($0) {
   return this.noSuchMethod("setDefinition", [$0]);
 };
 Object.prototype.setGenerateAtUseSite$0 = function() {
@@ skipping 200 matching lines @@
   } else {
     write(obj);
     write('\n');
   }
 }
 //  ********** Library dart:coreimpl **************
 // ********** Code for ListFactory **************
 ListFactory = Array;
 ListFactory.prototype.is$ListFactory = function(){return this;};
 ListFactory.prototype.is$List = function(){return this;};
-ListFactory.prototype.is$List$ArgumentNode = function(){return this;};
-ListFactory.prototype.is$List$Definition = function(){return this;};
-ListFactory.prototype.is$List$EvaluatedValue = function(){return this;};
-ListFactory.prototype.is$List$GlobalValue = function(){return this;};
-ListFactory.prototype.is$List$HInstruction = function(){return this;};
-ListFactory.prototype.is$List$Member = function(){return this;};
-ListFactory.prototype.is$List$String = function(){return this;};
-ListFactory.prototype.is$List$Token = function(){return this;};
-ListFactory.prototype.is$List$Type = function(){return this;};
-ListFactory.prototype.is$List$Value = function(){return this;};
-ListFactory.prototype.is$List$int = function(){return this;};
-ListFactory.prototype.is$Collection$E = function(){return this;};
-ListFactory.prototype.is$Collection$Object = function(){return this;};
-ListFactory.prototype.is$Collection$Type = function(){return this;};
+ListFactory.prototype.is$List_ArgumentNode = function(){return this;};
+ListFactory.prototype.is$List_Definition = function(){return this;};
+ListFactory.prototype.is$List_EvaluatedValue = function(){return this;};
+ListFactory.prototype.is$List_GlobalValue = function(){return this;};
+ListFactory.prototype.is$List_HInstruction = function(){return this;};
+ListFactory.prototype.is$List_Member = function(){return this;};
+ListFactory.prototype.is$List_ParameterType = function(){return this;};
+ListFactory.prototype.is$List_String = function(){return this;};
+ListFactory.prototype.is$List_Token = function(){return this;};
+ListFactory.prototype.is$List_Type = function(){return this;};
+ListFactory.prototype.is$List_Value = function(){return this;};
+ListFactory.prototype.is$List_int = function(){return this;};
+ListFactory.prototype.is$Collection_E = function(){return this;};
+ListFactory.prototype.is$Collection_Object = function(){return this;};
+ListFactory.prototype.is$Collection_Type = function(){return this;};
 ListFactory.prototype.is$Iterable = function(){return this;};
 ListFactory.ListFactory$from$factory = function(other) {
   var list = [];
   for (var $i = other.iterator(); $i.hasNext$0(); ) {
     var e = $i.next$0();
     list.add(e);
   }
   return (list && list.is$ListFactory());
 }
 ListFactory.prototype.add = function(value) {
@@ skipping 21 matching lines @@
   return this.slice(start, start + length);
 }
 ListFactory.prototype.isEmpty = function() {
   return this.length == 0;
 }
 ListFactory.prototype.iterator = function() {
   return new ListIterator(this);
 }
 ListFactory.prototype.add$1 = ListFactory.prototype.add;
 ListFactory.prototype.addAll$1 = function($0) {
-  return this.addAll(($0 && $0.is$Collection$E()));
+  return this.addAll(($0 && $0.is$Collection_E()));
 };
 ListFactory.prototype.every$1 = function($0) {
   return this.every(to$call$1($0));
 };
 ListFactory.prototype.filter$1 = function($0) {
   return this.filter(to$call$1($0));
 };
 ListFactory.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 ListFactory.prototype.indexOf$2 = function($0, $1) {
   return this.indexOf($0, $assert_num($1));
 };
 ListFactory.prototype.isEmpty$0 = ListFactory.prototype.isEmpty;
 ListFactory.prototype.iterator$0 = ListFactory.prototype.iterator;
 ListFactory.prototype.last$0 = ListFactory.prototype.last;
 ListFactory.prototype.removeLast$0 = ListFactory.prototype.removeLast;
 ListFactory.prototype.some$1 = function($0) {
   return this.some(to$call$1($0));
 };
 ListFactory.prototype.sort$1 = function($0) {
   return this.sort(to$call$2($0));
 };
-ListFactory$E = ListFactory;
-ListFactory$HBasicBlock = ListFactory;
-ListFactory$HInstruction = ListFactory;
-ListFactory$K = ListFactory;
-ListFactory$KeywordState = ListFactory;
-ListFactory$String = ListFactory;
-ListFactory$T = ListFactory;
-ListFactory$V = ListFactory;
-ListFactory$ValueSetNode = ListFactory;
-ListFactory$int = ListFactory;
+ListFactory_E = ListFactory;
+ListFactory_HBasicBlock = ListFactory;
+ListFactory_HInstruction = ListFactory;
+ListFactory_K = ListFactory;
+ListFactory_KeywordState = ListFactory;
+ListFactory_String = ListFactory;
+ListFactory_T = ListFactory;
+ListFactory_V = ListFactory;
+ListFactory_ValueSetNode = ListFactory;
+ListFactory_int = ListFactory;
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
   this._pos = 0;
   // Initializers done
 }
-ListIterator.prototype.is$Iterator$T = function(){return this;};
+ListIterator.prototype.is$Iterator_T = function(){return this;};
 ListIterator.prototype.hasNext = function() {
   return this._array.length > this._pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$0/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._pos++);
 }
 ListIterator.prototype.hasNext$0 = ListIterator.prototype.hasNext;
 ListIterator.prototype.next$0 = ListIterator.prototype.next;
 // ********** Code for ImmutableList **************
 function ImmutableList(length) {
   this._length = length;
   // Initializers done
-  ListFactory$E.call(this, length);
+  ListFactory_E.call(this, length);
 }
 /** 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;
   }
 }
-$inherits(ImmutableList, ListFactory$E);
+$inherits(ImmutableList, ListFactory_E);
 ImmutableList.ImmutableList$from$factory = function(other) {
   var list = new ImmutableList(other.length);
   for (var i = 0;
    i < other.length; i++) {
     list._setindex(i, other.$index(i));
   }
   return list;
 }
 ImmutableList.prototype.get$length = function() {
   return this._length;
@@ skipping 30 matching lines @@
   $throw(const$14/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.clear = function() {
   $throw(const$14/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.removeLast = function() {
   $throw(const$14/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.add$1 = ImmutableList.prototype.add;
 ImmutableList.prototype.addAll$1 = function($0) {
-  return this.addAll(($0 && $0.is$Collection$E()));
+  return this.addAll(($0 && $0.is$Collection_E()));
 };
 ImmutableList.prototype.removeLast$0 = ImmutableList.prototype.removeLast;
 ImmutableList.prototype.sort$1 = function($0) {
   return this.sort(to$call$2($0));
 };
 // ********** Code for ImmutableMap **************
 function ImmutableMap(keyValuePairs) {
   this._internal = $map([]);
   // Initializers done
   for (var i = 0;
    i < keyValuePairs.length; i += 2) {
     this._internal.$setindex(keyValuePairs.$index(i), keyValuePairs.$index(i + 1));
   }
 }
-ImmutableMap.prototype.is$Map$Node$Element = function(){return this;};
-ImmutableMap.prototype.is$Map$String$Member = function(){return this;};
+ImmutableMap.prototype.is$Map_Node$Element = function(){return this;};
+ImmutableMap.prototype.is$Map_String$Member = function(){return this;};
 ImmutableMap.prototype.$index = function(key) {
   return this._internal.$index(key);
 }
 ImmutableMap.prototype.isEmpty = function() {
   return this._internal.isEmpty();
 }
 ImmutableMap.prototype.get$length = function() {
   return this._internal.get$length();
 }
 Object.defineProperty(ImmutableMap.prototype, "length", {
@@ skipping 96 matching lines @@
 // ********** Code for HashMapImplementation **************
 function HashMapImplementation() {
   // Initializers done
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 HashMapImplementation.prototype.is$HashMapImplementation = function(){return this;};
-HashMapImplementation.prototype.is$Map$Node$Element = function(){return this;};
-HashMapImplementation.prototype.is$Map$String$Member = function(){return this;};
+HashMapImplementation.prototype.is$Map_Node$Element = function(){return this;};
+HashMapImplementation.prototype.is$Map_String$Member = function(){return this;};
 HashMapImplementation.HashMapImplementation$from$factory = function(other) {
   var result = new HashMapImplementation();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
   })
   );
   return (result && result.is$HashMapImplementation());
 }
 HashMapImplementation._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
@@ skipping 153 matching lines @@
 }
 HashMapImplementation.prototype.containsKey = function(key) {
   return (this._probeForLookup(key) != -1);
 }
 HashMapImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 HashMapImplementation.prototype.getKeys$0 = HashMapImplementation.prototype.getKeys;
 HashMapImplementation.prototype.getValues$0 = HashMapImplementation.prototype.getValues;
 HashMapImplementation.prototype.isEmpty$0 = HashMapImplementation.prototype.isEmpty;
-// ********** Code for HashMapImplementation$E$E **************
-function HashMapImplementation$E$E() {
+// ********** Code for HashMapImplementation_E$E **************
+function HashMapImplementation_E$E() {
   // Initializers done
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
-$inherits(HashMapImplementation$E$E, HashMapImplementation);
-HashMapImplementation$E$E.prototype.is$Map$Node$Element = function(){return this;};
-HashMapImplementation$E$E.prototype.is$Map$String$Member = function(){return this;};
-HashMapImplementation$E$E._computeLoadLimit = function(capacity) {
+$inherits(HashMapImplementation_E$E, HashMapImplementation);
+HashMapImplementation_E$E.prototype.is$Map_Node$Element = function(){return this;};
+HashMapImplementation_E$E.prototype.is$Map_String$Member = function(){return this;};
+HashMapImplementation_E$E._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
-HashMapImplementation$E$E._firstProbe = function(hashCode, length) {
+HashMapImplementation_E$E._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
-HashMapImplementation$E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
+HashMapImplementation_E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - 1);
 }
-HashMapImplementation$E$E.prototype._probeForAdding = function(key) {
+HashMapImplementation_E$E.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe($assert_num(key.hashCode$0()), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   var insertionIndex = -1;
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < 0) return hash;
       return insertionIndex;
     }
     else if ($notnull_bool($eq(existingKey, key))) {
       return hash;
     }
     else if ((insertionIndex < 0) && (const$1/*HashMapImplementation._DELETED_KEY*/ === existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
-HashMapImplementation$E$E.prototype._probeForLookup = function(key) {
+HashMapImplementation_E$E.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe($assert_num(key.hashCode$0()), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) return -1;
     if ($notnull_bool($eq(existingKey, key))) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
-HashMapImplementation$E$E.prototype._ensureCapacity = function() {
+HashMapImplementation_E$E.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + 1;
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.length * 2);
     return;
   }
   var capacity = this._keys.length;
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if (this._numberOfDeleted > numberOfFree) {
     this._grow(this._keys.length);
   }
 }
-HashMapImplementation$E$E._isPowerOfTwo = function(x) {
+HashMapImplementation_E$E._isPowerOfTwo = function(x) {
   return ((x & (x - 1)) == 0);
 }
-HashMapImplementation$E$E.prototype._grow = function(newCapacity) {
+HashMapImplementation_E$E.prototype._grow = function(newCapacity) {
   $assert(HashMapImplementation._isPowerOfTwo(newCapacity), "_isPowerOfTwo(newCapacity)", "hash_map_set.dart", 149, 12);
   var capacity = this._keys.length;
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new ListFactory(newCapacity);
   this._values = new ListFactory(newCapacity);
   for (var i = 0;
    i < capacity; i++) {
     var key = oldKeys.$index(i);
     if (key == null || key === const$1/*HashMapImplementation._DELETED_KEY*/) {
       continue;
     }
     var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = 0;
 }
-HashMapImplementation$E$E.prototype.clear = function() {
+HashMapImplementation_E$E.prototype.clear = function() {
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   var length = this._keys.length;
   for (var i = 0;
    i < length; i++) {
     this._keys.$setindex(i);
     this._values.$setindex(i);
   }
 }
-HashMapImplementation$E$E.prototype.$setindex = function(key, value) {
+HashMapImplementation_E$E.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
   if ((this._keys.$index(index) == null) || (this._keys.$index(index) === const$1/*HashMapImplementation._DELETED_KEY*/)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
-HashMapImplementation$E$E.prototype.remove = function(key) {
+HashMapImplementation_E$E.prototype.remove = function(key) {
   var index = this._probeForLookup(key);
   if (index >= 0) {
     this._numberOfEntries--;
     var value = this._values.$index(index);
     this._values.$setindex(index);
     this._keys.$setindex(index, const$1/*HashMapImplementation._DELETED_KEY*/);
     this._numberOfDeleted++;
     return value;
   }
   return null;
 }
-HashMapImplementation$E$E.prototype.isEmpty = function() {
+HashMapImplementation_E$E.prototype.isEmpty = function() {
   return this._numberOfEntries == 0;
 }
-HashMapImplementation$E$E.prototype.forEach = function(f) {
+HashMapImplementation_E$E.prototype.forEach = function(f) {
   var length = this._keys.length;
   for (var i = 0;
    i < length; i++) {
     if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== const$1/*HashMapImplementation._DELETED_KEY*/)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
-HashMapImplementation$E$E.prototype.getKeys = function() {
+HashMapImplementation_E$E.prototype.getKeys = function() {
   var list = new ListFactory(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
   return list;
 }
-HashMapImplementation$E$E.prototype.containsKey = function(key) {
+HashMapImplementation_E$E.prototype.containsKey = function(key) {
   return (this._probeForLookup(key) != -1);
 }
-// ********** Code for HashMapImplementation$Element$HInstruction **************
-function HashMapImplementation$Element$HInstruction() {}
-$inherits(HashMapImplementation$Element$HInstruction, HashMapImplementation);
-HashMapImplementation$Element$HInstruction.prototype.is$Map$Node$Element = false;
-HashMapImplementation$Element$HInstruction.prototype.is$Map$String$Member = false;
-// ********** Code for HashMapImplementation$Element$HLocal **************
-function HashMapImplementation$Element$HLocal() {}
-$inherits(HashMapImplementation$Element$HLocal, HashMapImplementation);
-HashMapImplementation$Element$HLocal.prototype.is$Map$Node$Element = false;
-HashMapImplementation$Element$HLocal.prototype.is$Map$String$Member = false;
-// ********** Code for HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V **************
-function HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V() {}
-$inherits(HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V, HashMapImplementation);
-HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.is$Map$Node$Element = false;
-HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.is$Map$String$Member = false;
-// ********** Code for HashMapImplementation$String$EvaluatedValue **************
-function HashMapImplementation$String$EvaluatedValue() {}
-$inherits(HashMapImplementation$String$EvaluatedValue, HashMapImplementation);
-HashMapImplementation$String$EvaluatedValue.prototype.is$Map$Node$Element = false;
-HashMapImplementation$String$EvaluatedValue.prototype.is$Map$String$Member = false;
-// ********** Code for HashMapImplementation$String$int **************
-function HashMapImplementation$String$int() {}
-$inherits(HashMapImplementation$String$int, HashMapImplementation);
-HashMapImplementation$String$int.prototype.is$Map$Node$Element = false;
-HashMapImplementation$String$int.prototype.is$Map$String$Member = false;
-// ********** Code for HashMapImplementation$int$HInstruction **************
-function HashMapImplementation$int$HInstruction() {}
-$inherits(HashMapImplementation$int$HInstruction, HashMapImplementation);
-HashMapImplementation$int$HInstruction.prototype.is$Map$Node$Element = false;
-HashMapImplementation$int$HInstruction.prototype.is$Map$String$Member = false;
-// ********** Code for HashMapImplementation$int$String **************
-function HashMapImplementation$int$String() {}
-$inherits(HashMapImplementation$int$String, HashMapImplementation);
-HashMapImplementation$int$String.prototype.is$Map$Node$Element = false;
-HashMapImplementation$int$String.prototype.is$Map$String$Member = false;
+// ********** Code for HashMapImplementation_Element$HInstruction **************
+function HashMapImplementation_Element$HInstruction() {}
+$inherits(HashMapImplementation_Element$HInstruction, HashMapImplementation);
+HashMapImplementation_Element$HInstruction.prototype.is$Map_Node$Element = false;
+HashMapImplementation_Element$HInstruction.prototype.is$Map_String$Member = false;
+// ********** Code for HashMapImplementation_Element$HLocal **************
+function HashMapImplementation_Element$HLocal() {}
+$inherits(HashMapImplementation_Element$HLocal, HashMapImplementation);
+HashMapImplementation_Element$HLocal.prototype.is$Map_Node$Element = false;
+HashMapImplementation_Element$HLocal.prototype.is$Map_String$Member = false;
+// ********** Code for HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V **************
+function HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V() {}
+$inherits(HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V, HashMapImplementation);
+HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype.is$Map_Node$Element = false;
+HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype.is$Map_String$Member = false;
+// ********** Code for HashMapImplementation_String$EvaluatedValue **************
+function HashMapImplementation_String$EvaluatedValue() {}
+$inherits(HashMapImplementation_String$EvaluatedValue, HashMapImplementation);
+HashMapImplementation_String$EvaluatedValue.prototype.is$Map_Node$Element = false;
+HashMapImplementation_String$EvaluatedValue.prototype.is$Map_String$Member = false;
+// ********** Code for HashMapImplementation_String$int **************
+function HashMapImplementation_String$int() {}
+$inherits(HashMapImplementation_String$int, HashMapImplementation);
+HashMapImplementation_String$int.prototype.is$Map_Node$Element = false;
+HashMapImplementation_String$int.prototype.is$Map_String$Member = false;
+// ********** Code for HashMapImplementation_int$HInstruction **************
+function HashMapImplementation_int$HInstruction() {}
+$inherits(HashMapImplementation_int$HInstruction, HashMapImplementation);
+HashMapImplementation_int$HInstruction.prototype.is$Map_Node$Element = false;
+HashMapImplementation_int$HInstruction.prototype.is$Map_String$Member = false;
+// ********** Code for HashMapImplementation_int$String **************
+function HashMapImplementation_int$String() {}
+$inherits(HashMapImplementation_int$String, HashMapImplementation);
+HashMapImplementation_int$String.prototype.is$Map_Node$Element = false;
+HashMapImplementation_int$String.prototype.is$Map_String$Member = false;
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
   // Initializers done
-  this._backingMap = new HashMapImplementation$E$E();
+  this._backingMap = new HashMapImplementation_E$E();
 }
 HashSetImplementation.prototype.is$HashSetImplementation = function(){return this;};
-HashSetImplementation.prototype.is$Collection$E = function(){return this;};
-HashSetImplementation.prototype.is$Collection$Object = function(){return this;};
-HashSetImplementation.prototype.is$Collection$Type = function(){return this;};
+HashSetImplementation.prototype.is$Collection_E = function(){return this;};
+HashSetImplementation.prototype.is$Collection_Object = function(){return this;};
+HashSetImplementation.prototype.is$Collection_Type = function(){return this;};
 HashSetImplementation.prototype.is$Iterable = function(){return this;};
 HashSetImplementation.HashSetImplementation$from$factory = function(other) {
   var set = new HashSetImplementation();
   for (var $i = other.iterator(); $i.hasNext$0(); ) {
     var e = $i.next$0();
     set.add(e);
   }
   return (set && set.is$HashSetImplementation());
 }
 HashSetImplementation.prototype.clear = function() {
@@ skipping 42 matching lines @@
 HashSetImplementation.prototype.isEmpty = function() {
   return this._backingMap.isEmpty();
 }
 HashSetImplementation.prototype.get$length = function() {
   return this._backingMap.get$length();
 }
 Object.defineProperty(HashSetImplementation.prototype, "length", {
   get: HashSetImplementation.prototype.get$length
 });
 HashSetImplementation.prototype.iterator = function() {
-  return new HashSetIterator$E(this);
+  return new HashSetIterator_E(this);
 }
 HashSetImplementation.prototype.add$1 = HashSetImplementation.prototype.add;
 HashSetImplementation.prototype.addAll$1 = function($0) {
-  return this.addAll(($0 && $0.is$Collection$E()));
+  return this.addAll(($0 && $0.is$Collection_E()));
 };
 HashSetImplementation.prototype.contains$1 = HashSetImplementation.prototype.contains;
 HashSetImplementation.prototype.every$1 = function($0) {
   return this.every(to$call$1($0));
 };
 HashSetImplementation.prototype.filter$1 = function($0) {
   return this.filter(to$call$1($0));
 };
 HashSetImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 HashSetImplementation.prototype.isEmpty$0 = HashSetImplementation.prototype.isEmpty;
 HashSetImplementation.prototype.iterator$0 = HashSetImplementation.prototype.iterator;
 HashSetImplementation.prototype.some$1 = function($0) {
   return this.some(to$call$1($0));
 };
-// ********** Code for HashSetImplementation$E **************
-function HashSetImplementation$E() {}
-$inherits(HashSetImplementation$E, HashSetImplementation);
-HashSetImplementation$E.prototype.is$Collection$E = function(){return this;};
-HashSetImplementation$E.prototype.is$Collection$Object = function(){return this;};
-HashSetImplementation$E.prototype.is$Collection$Type = function(){return this;};
-HashSetImplementation$E.prototype.is$Iterable = function(){return this;};
-// ********** Code for HashSetImplementation$HPhi **************
-function HashSetImplementation$HPhi() {}
-$inherits(HashSetImplementation$HPhi, HashSetImplementation);
-HashSetImplementation$HPhi.prototype.is$Collection$E = function(){return this;};
-HashSetImplementation$HPhi.prototype.is$Collection$Object = function(){return this;};
-HashSetImplementation$HPhi.prototype.is$Collection$Type = false;
-HashSetImplementation$HPhi.prototype.is$Iterable = function(){return this;};
-// ********** Code for HashSetImplementation$String **************
-function HashSetImplementation$String() {}
-$inherits(HashSetImplementation$String, HashSetImplementation);
-HashSetImplementation$String.prototype.is$Collection$E = function(){return this;};
-HashSetImplementation$String.prototype.is$Collection$Object = function(){return this;};
-HashSetImplementation$String.prototype.is$Collection$Type = false;
-HashSetImplementation$String.prototype.is$Iterable = function(){return this;};
-// ********** Code for HashSetImplementation$Type **************
-function HashSetImplementation$Type() {}
-$inherits(HashSetImplementation$Type, HashSetImplementation);
-HashSetImplementation$Type.prototype.is$Collection$E = function(){return this;};
-HashSetImplementation$Type.prototype.is$Collection$Object = function(){return this;};
-HashSetImplementation$Type.prototype.is$Collection$Type = function(){return this;};
-HashSetImplementation$Type.prototype.is$Iterable = function(){return this;};
-// ********** Code for HashSetImplementation$int **************
-function HashSetImplementation$int() {}
-$inherits(HashSetImplementation$int, HashSetImplementation);
-HashSetImplementation$int.prototype.is$Collection$E = function(){return this;};
-HashSetImplementation$int.prototype.is$Collection$Object = function(){return this;};
-HashSetImplementation$int.prototype.is$Collection$Type = false;
-HashSetImplementation$int.prototype.is$Iterable = function(){return this;};
+// ********** Code for HashSetImplementation_E **************
+function HashSetImplementation_E() {}
+$inherits(HashSetImplementation_E, HashSetImplementation);
+HashSetImplementation_E.prototype.is$Collection_E = function(){return this;};
+HashSetImplementation_E.prototype.is$Collection_Object = function(){return this;};
+HashSetImplementation_E.prototype.is$Collection_Type = function(){return this;};
+HashSetImplementation_E.prototype.is$Iterable = function(){return this;};
+// ********** Code for HashSetImplementation_HPhi **************
+function HashSetImplementation_HPhi() {}
+$inherits(HashSetImplementation_HPhi, HashSetImplementation);
+HashSetImplementation_HPhi.prototype.is$Collection_E = function(){return this;};
+HashSetImplementation_HPhi.prototype.is$Collection_Object = function(){return this;};
+HashSetImplementation_HPhi.prototype.is$Collection_Type = false;
+HashSetImplementation_HPhi.prototype.is$Iterable = function(){return this;};
+// ********** Code for HashSetImplementation_String **************
+function HashSetImplementation_String() {}
+$inherits(HashSetImplementation_String, HashSetImplementation);
+HashSetImplementation_String.prototype.is$Collection_E = function(){return this;};
+HashSetImplementation_String.prototype.is$Collection_Object = function(){return this;};
+HashSetImplementation_String.prototype.is$Collection_Type = false;
+HashSetImplementation_String.prototype.is$Iterable = function(){return this;};
+// ********** Code for HashSetImplementation_lang_Type **************
+function HashSetImplementation_lang_Type() {}
+$inherits(HashSetImplementation_lang_Type, HashSetImplementation);
+HashSetImplementation_lang_Type.prototype.is$Collection_E = function(){return this;};
+HashSetImplementation_lang_Type.prototype.is$Collection_Object = function(){return this;};
+HashSetImplementation_lang_Type.prototype.is$Collection_Type = function(){return this;};
+HashSetImplementation_lang_Type.prototype.is$Iterable = function(){return this;};
+// ********** Code for HashSetImplementation_int **************
+function HashSetImplementation_int() {}
+$inherits(HashSetImplementation_int, HashSetImplementation);
+HashSetImplementation_int.prototype.is$Collection_E = function(){return this;};
+HashSetImplementation_int.prototype.is$Collection_Object = function(){return this;};
+HashSetImplementation_int.prototype.is$Collection_Type = false;
+HashSetImplementation_int.prototype.is$Iterable = function(){return this;};
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
   this._nextValidIndex = -1;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
-HashSetIterator.prototype.is$Iterator$T = function(){return this;};
+HashSetIterator.prototype.is$Iterator_T = function(){return this;};
 HashSetIterator.prototype.hasNext = function() {
   if (this._nextValidIndex >= this._entries.length) return false;
   if (this._entries.$index(this._nextValidIndex) === const$1/*HashMapImplementation._DELETED_KEY*/) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.length;
 }
 HashSetIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$0/*const NoMoreElementsException()*/);
   }
   var res = this._entries.$index(this._nextValidIndex);
   this._advance();
   return res;
 }
 HashSetIterator.prototype._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = const$1/*HashMapImplementation._DELETED_KEY*/;
   do {
     if (++this._nextValidIndex >= length) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
   while ((entry == null) || (entry === deletedKey))
 }
 HashSetIterator.prototype.hasNext$0 = HashSetIterator.prototype.hasNext;
 HashSetIterator.prototype.next$0 = HashSetIterator.prototype.next;
-// ********** Code for HashSetIterator$E **************
-function HashSetIterator$E(set_) {
+// ********** Code for HashSetIterator_E **************
+function HashSetIterator_E(set_) {
   this._nextValidIndex = -1;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
-$inherits(HashSetIterator$E, HashSetIterator);
-HashSetIterator$E.prototype.is$Iterator$T = function(){return this;};
-HashSetIterator$E.prototype._advance = function() {
+$inherits(HashSetIterator_E, HashSetIterator);
+HashSetIterator_E.prototype.is$Iterator_T = function(){return this;};
+HashSetIterator_E.prototype._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = const$1/*HashMapImplementation._DELETED_KEY*/;
   do {
     if (++this._nextValidIndex >= length) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
   while ((entry == null) || (entry === deletedKey))
 }
 // ********** Code for _DeletedKeySentinel **************
 function _DeletedKeySentinel() {
   // Initializers done
 }
 // ********** Code for KeyValuePair **************
 function KeyValuePair(key, value) {
   this.key = key;
   this.value = value;
   // Initializers done
 }
 KeyValuePair.prototype.get$value = function() { return this.value; };
 KeyValuePair.prototype.set$value = function(value) { return this.value = value; };
-// ********** Code for KeyValuePair$K$V **************
-function KeyValuePair$K$V(key, value) {
+// ********** Code for KeyValuePair_K$V **************
+function KeyValuePair_K$V(key, value) {
   this.key = key;
   this.value = value;
   // Initializers done
 }
-$inherits(KeyValuePair$K$V, KeyValuePair);
+$inherits(KeyValuePair_K$V, KeyValuePair);
 // ********** Code for LinkedHashMapImplementation **************
 function LinkedHashMapImplementation() {
   // Initializers done
   this._map = new HashMapImplementation();
-  this._list = new DoubleLinkedQueue$KeyValuePair$K$V();
+  this._list = new DoubleLinkedQueue_KeyValuePair_K$V();
 }
-LinkedHashMapImplementation.prototype.is$Map$Node$Element = function(){return this;};
-LinkedHashMapImplementation.prototype.is$Map$String$Member = function(){return this;};
+LinkedHashMapImplementation.prototype.is$Map_Node$Element = function(){return this;};
+LinkedHashMapImplementation.prototype.is$Map_String$Member = function(){return this;};
 LinkedHashMapImplementation.prototype.$setindex = function(key, value) {
   if (this._map.containsKey(key)) {
     this._map.$index(key).get$element().set$value(value);
   }
   else {
-    this._list.addLast(new KeyValuePair$K$V(key, value));
+    this._list.addLast(new KeyValuePair_K$V(key, value));
     this._map.$setindex(key, this._list.lastEntry());
   }
 }
 LinkedHashMapImplementation.prototype.$index = function(key) {
   var $0;
-  var entry = (($0 = this._map.$index(key)) && $0.is$DoubleLinkedQueueEntry$KeyValuePair$K$V());
+  var entry = (($0 = this._map.$index(key)) && $0.is$DoubleLinkedQueueEntry_KeyValuePair_K$V());
   if (entry == null) return null;
   return entry.get$element().get$value();
 }
 LinkedHashMapImplementation.prototype.remove = function(key) {
   var $0;
-  var entry = (($0 = this._map.remove(key)) && $0.is$DoubleLinkedQueueEntry$KeyValuePair$K$V());
+  var entry = (($0 = this._map.remove(key)) && $0.is$DoubleLinkedQueueEntry_KeyValuePair_K$V());
   if (entry == null) return null;
   entry.remove();
   return entry.get$element().get$value();
 }
 LinkedHashMapImplementation.prototype.putIfAbsent = function(key, ifAbsent) {
   var value = this.$index(key);
   if ((this.$index(key) == null) && !(this.containsKey(key))) {
     value = ifAbsent();
     this.$setindex(key, value);
   }
@@ skipping 36 matching lines @@
 });
 LinkedHashMapImplementation.prototype.isEmpty = function() {
   return this.get$length() == 0;
 }
 LinkedHashMapImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 LinkedHashMapImplementation.prototype.getKeys$0 = LinkedHashMapImplementation.prototype.getKeys;
 LinkedHashMapImplementation.prototype.getValues$0 = LinkedHashMapImplementation.prototype.getValues;
 LinkedHashMapImplementation.prototype.isEmpty$0 = LinkedHashMapImplementation.prototype.isEmpty;
-// ********** Code for LinkedHashMapImplementation$Element$String **************
-function LinkedHashMapImplementation$Element$String() {}
-$inherits(LinkedHashMapImplementation$Element$String, LinkedHashMapImplementation);
-LinkedHashMapImplementation$Element$String.prototype.is$Map$Node$Element = false;
-LinkedHashMapImplementation$Element$String.prototype.is$Map$String$Member = false;
-// ********** Code for LinkedHashMapImplementation$Node$Element **************
-function LinkedHashMapImplementation$Node$Element() {}
-$inherits(LinkedHashMapImplementation$Node$Element, LinkedHashMapImplementation);
-LinkedHashMapImplementation$Node$Element.prototype.is$Map$Node$Element = function(){return this;};
-LinkedHashMapImplementation$Node$Element.prototype.is$Map$String$Member = false;
-// ********** Code for LinkedHashMapImplementation$String$Keyword **************
-function LinkedHashMapImplementation$String$Keyword() {}
-$inherits(LinkedHashMapImplementation$String$Keyword, LinkedHashMapImplementation);
-LinkedHashMapImplementation$String$Keyword.prototype.is$Map$Node$Element = false;
-LinkedHashMapImplementation$String$Keyword.prototype.is$Map$String$Member = false;
+// ********** Code for LinkedHashMapImplementation_Element$String **************
+function LinkedHashMapImplementation_Element$String() {}
+$inherits(LinkedHashMapImplementation_Element$String, LinkedHashMapImplementation);
+LinkedHashMapImplementation_Element$String.prototype.is$Map_Node$Element = false;
+LinkedHashMapImplementation_Element$String.prototype.is$Map_String$Member = false;
+// ********** Code for LinkedHashMapImplementation_Node$Element **************
+function LinkedHashMapImplementation_Node$Element() {}
+$inherits(LinkedHashMapImplementation_Node$Element, LinkedHashMapImplementation);
+LinkedHashMapImplementation_Node$Element.prototype.is$Map_Node$Element = function(){return this;};
+LinkedHashMapImplementation_Node$Element.prototype.is$Map_String$Member = false;
+// ********** Code for LinkedHashMapImplementation_String$Keyword **************
+function LinkedHashMapImplementation_String$Keyword() {}
+$inherits(LinkedHashMapImplementation_String$Keyword, LinkedHashMapImplementation);
+LinkedHashMapImplementation_String$Keyword.prototype.is$Map_Node$Element = false;
+LinkedHashMapImplementation_String$Keyword.prototype.is$Map_String$Member = false;
 // ********** Code for DoubleLinkedQueueEntry **************
 function DoubleLinkedQueueEntry(e) {
   // Initializers done
   this._element = e;
 }
-DoubleLinkedQueueEntry.prototype.is$DoubleLinkedQueueEntry$KeyValuePair$K$V = function(){return this;};
+DoubleLinkedQueueEntry.prototype.is$DoubleLinkedQueueEntry_KeyValuePair_K$V = function(){return this;};
 DoubleLinkedQueueEntry.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
 }
 DoubleLinkedQueueEntry.prototype.prepend = function(e) {
-  new DoubleLinkedQueueEntry$E(e)._link(this._previous, this);
+  new DoubleLinkedQueueEntry_E(e)._link(this._previous, this);
 }
 DoubleLinkedQueueEntry.prototype.remove = function() {
   this._previous._next = this._next;
   this._next._previous = this._previous;
   this._next = null;
   this._previous = null;
   return this._element;
 }
 DoubleLinkedQueueEntry.prototype._asNonSentinelEntry = function() {
   return this;
 }
 DoubleLinkedQueueEntry.prototype.previousEntry = function() {
   return this._previous._asNonSentinelEntry();
 }
 DoubleLinkedQueueEntry.prototype.get$element = function() {
   return this._element;
 }
-// ********** Code for DoubleLinkedQueueEntry$E **************
-function DoubleLinkedQueueEntry$E(e) {
+// ********** Code for DoubleLinkedQueueEntry_E **************
+function DoubleLinkedQueueEntry_E(e) {
   // Initializers done
   this._element = e;
 }
-$inherits(DoubleLinkedQueueEntry$E, DoubleLinkedQueueEntry);
-DoubleLinkedQueueEntry$E.prototype.is$DoubleLinkedQueueEntry$KeyValuePair$K$V = function(){return this;};
-DoubleLinkedQueueEntry$E.prototype._link = function(p, n) {
+$inherits(DoubleLinkedQueueEntry_E, DoubleLinkedQueueEntry);
+DoubleLinkedQueueEntry_E.prototype.is$DoubleLinkedQueueEntry_KeyValuePair_K$V = function(){return this;};
+DoubleLinkedQueueEntry_E.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
 }
-DoubleLinkedQueueEntry$E.prototype.prepend = function(e) {
-  new DoubleLinkedQueueEntry$E(e)._link(this._previous, this);
+DoubleLinkedQueueEntry_E.prototype.prepend = function(e) {
+  new DoubleLinkedQueueEntry_E(e)._link(this._previous, this);
 }
-DoubleLinkedQueueEntry$E.prototype.remove = function() {
+DoubleLinkedQueueEntry_E.prototype.remove = function() {
   this._previous._next = this._next;
   this._next._previous = this._previous;
   this._next = null;
   this._previous = null;
   return this._element;
 }
-DoubleLinkedQueueEntry$E.prototype._asNonSentinelEntry = function() {
+DoubleLinkedQueueEntry_E.prototype._asNonSentinelEntry = function() {
   return this;
 }
-DoubleLinkedQueueEntry$E.prototype.previousEntry = function() {
+DoubleLinkedQueueEntry_E.prototype.previousEntry = function() {
   return this._previous._asNonSentinelEntry();
 }
-// ********** Code for DoubleLinkedQueueEntry$KeyValuePair$K$V **************
-function DoubleLinkedQueueEntry$KeyValuePair$K$V(e) {
+// ********** Code for DoubleLinkedQueueEntry_KeyValuePair_K$V **************
+function DoubleLinkedQueueEntry_KeyValuePair_K$V(e) {
   // Initializers done
   this._element = e;
 }
-$inherits(DoubleLinkedQueueEntry$KeyValuePair$K$V, DoubleLinkedQueueEntry);
-DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.is$DoubleLinkedQueueEntry$KeyValuePair$K$V = function(){return this;};
-DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype._link = function(p, n) {
+$inherits(DoubleLinkedQueueEntry_KeyValuePair_K$V, DoubleLinkedQueueEntry);
+DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype.is$DoubleLinkedQueueEntry_KeyValuePair_K$V = function(){return this;};
+DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
 }
-DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.prepend = function(e) {
-  new DoubleLinkedQueueEntry$KeyValuePair$K$V(e)._link(this._previous, this);
+DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype.prepend = function(e) {
+  new DoubleLinkedQueueEntry_KeyValuePair_K$V(e)._link(this._previous, this);
 }
-DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.remove = function() {
+DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype.remove = function() {
   this._previous._next = this._next;
   this._next._previous = this._previous;
   this._next = null;
   this._previous = null;
   return this._element;
 }
-DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype._asNonSentinelEntry = function() {
+DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype._asNonSentinelEntry = function() {
   return this;
 }
-DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.previousEntry = function() {
+DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype.previousEntry = function() {
   var $0;
-  return (($0 = this._previous._asNonSentinelEntry()) && $0.is$DoubleLinkedQueueEntry$KeyValuePair$K$V());
+  return (($0 = this._previous._asNonSentinelEntry()) && $0.is$DoubleLinkedQueueEntry_KeyValuePair_K$V());
 }
 // ********** Code for _DoubleLinkedQueueEntrySentinel **************
 function _DoubleLinkedQueueEntrySentinel() {
   // Initializers done
-  DoubleLinkedQueueEntry$E.call(this, null);
+  DoubleLinkedQueueEntry_E.call(this, null);
   this._link(this, this);
 }
-$inherits(_DoubleLinkedQueueEntrySentinel, DoubleLinkedQueueEntry$E);
+$inherits(_DoubleLinkedQueueEntrySentinel, DoubleLinkedQueueEntry_E);
 _DoubleLinkedQueueEntrySentinel.prototype.remove = function() {
   $throw(const$5/*const EmptyQueueException()*/);
 }
 _DoubleLinkedQueueEntrySentinel.prototype._asNonSentinelEntry = function() {
   return null;
 }
 _DoubleLinkedQueueEntrySentinel.prototype.get$element = function() {
   $throw(const$5/*const EmptyQueueException()*/);
 }
-// ********** Code for _DoubleLinkedQueueEntrySentinel$E **************
-function _DoubleLinkedQueueEntrySentinel$E() {
+// ********** Code for _DoubleLinkedQueueEntrySentinel_E **************
+function _DoubleLinkedQueueEntrySentinel_E() {
   // Initializers done
-  DoubleLinkedQueueEntry$E.call(this, null);
+  DoubleLinkedQueueEntry_E.call(this, null);
   this._link(this, this);
 }
-$inherits(_DoubleLinkedQueueEntrySentinel$E, _DoubleLinkedQueueEntrySentinel);
-// ********** Code for _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V **************
-function _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V() {
+$inherits(_DoubleLinkedQueueEntrySentinel_E, _DoubleLinkedQueueEntrySentinel);
+// ********** Code for _DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V **************
+function _DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V() {
   // Initializers done
-  DoubleLinkedQueueEntry$KeyValuePair$K$V.call(this, null);
+  DoubleLinkedQueueEntry_KeyValuePair_K$V.call(this, null);
   this._link(this, this);
 }
-$inherits(_DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V, _DoubleLinkedQueueEntrySentinel);
+$inherits(_DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V, _DoubleLinkedQueueEntrySentinel);
 // ********** Code for DoubleLinkedQueue **************
 function DoubleLinkedQueue() {
   // Initializers done
-  this._sentinel = new _DoubleLinkedQueueEntrySentinel$E();
+  this._sentinel = new _DoubleLinkedQueueEntrySentinel_E();
 }
-DoubleLinkedQueue.prototype.is$Collection$E = function(){return this;};
-DoubleLinkedQueue.prototype.is$Collection$Object = function(){return this;};
-DoubleLinkedQueue.prototype.is$Collection$Type = function(){return this;};
+DoubleLinkedQueue.prototype.is$Collection_E = function(){return this;};
+DoubleLinkedQueue.prototype.is$Collection_Object = function(){return this;};
+DoubleLinkedQueue.prototype.is$Collection_Type = function(){return this;};
 DoubleLinkedQueue.prototype.is$Iterable = function(){return this;};
 DoubleLinkedQueue.prototype.addLast = function(value) {
   this._sentinel.prepend(value);
 }
 DoubleLinkedQueue.prototype.add = function(value) {
   this.addLast(value);
 }
 DoubleLinkedQueue.prototype.addAll = function(collection) {
   for (var $i = collection.iterator(); $i.hasNext$0(); ) {
     var e = $i.next$0();
@@ skipping 56 matching lines @@
   var other = new DoubleLinkedQueue();
   var entry = this._sentinel._next;
   while (entry !== this._sentinel) {
     var nextEntry = entry._next;
     if (f(entry._element)) other.addLast(entry._element);
     entry = nextEntry;
   }
   return other;
 }
 DoubleLinkedQueue.prototype.iterator = function() {
-  return new _DoubleLinkedQueueIterator$E(this._sentinel);
+  return new _DoubleLinkedQueueIterator_E(this._sentinel);
 }
 DoubleLinkedQueue.prototype.add$1 = DoubleLinkedQueue.prototype.add;
 DoubleLinkedQueue.prototype.addAll$1 = function($0) {
-  return this.addAll(($0 && $0.is$Collection$E()));
+  return this.addAll(($0 && $0.is$Collection_E()));
 };
 DoubleLinkedQueue.prototype.every$1 = function($0) {
   return this.every(to$call$1($0));
 };
 DoubleLinkedQueue.prototype.filter$1 = function($0) {
   return this.filter(to$call$1($0));
 };
 DoubleLinkedQueue.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 DoubleLinkedQueue.prototype.isEmpty$0 = DoubleLinkedQueue.prototype.isEmpty;
 DoubleLinkedQueue.prototype.iterator$0 = DoubleLinkedQueue.prototype.iterator;
 DoubleLinkedQueue.prototype.last$0 = DoubleLinkedQueue.prototype.last;
 DoubleLinkedQueue.prototype.removeLast$0 = DoubleLinkedQueue.prototype.removeLast;
 DoubleLinkedQueue.prototype.some$1 = function($0) {
   return this.some(to$call$1($0));
 };
-// ********** Code for DoubleLinkedQueue$ClassElement **************
-function DoubleLinkedQueue$ClassElement() {}
-$inherits(DoubleLinkedQueue$ClassElement, DoubleLinkedQueue);
-DoubleLinkedQueue$ClassElement.prototype.is$Collection$E = function(){return this;};
-DoubleLinkedQueue$ClassElement.prototype.is$Collection$Object = function(){return this;};
-DoubleLinkedQueue$ClassElement.prototype.is$Collection$Type = false;
-DoubleLinkedQueue$ClassElement.prototype.is$Iterable = function(){return this;};
-// ********** Code for DoubleLinkedQueue$E **************
-function DoubleLinkedQueue$E() {}
-$inherits(DoubleLinkedQueue$E, DoubleLinkedQueue);
-DoubleLinkedQueue$E.prototype.is$Collection$E = function(){return this;};
-DoubleLinkedQueue$E.prototype.is$Collection$Object = function(){return this;};
-DoubleLinkedQueue$E.prototype.is$Collection$Type = function(){return this;};
-DoubleLinkedQueue$E.prototype.is$Iterable = function(){return this;};
-// ********** Code for DoubleLinkedQueue$Element **************
-function DoubleLinkedQueue$Element() {}
-$inherits(DoubleLinkedQueue$Element, DoubleLinkedQueue);
-DoubleLinkedQueue$Element.prototype.is$Collection$E = function(){return this;};
-DoubleLinkedQueue$Element.prototype.is$Collection$Object = function(){return this;};
-DoubleLinkedQueue$Element.prototype.is$Collection$Type = false;
-DoubleLinkedQueue$Element.prototype.is$Iterable = function(){return this;};
-// ********** Code for DoubleLinkedQueue$KeyValuePair$K$V **************
-function DoubleLinkedQueue$KeyValuePair$K$V() {
+// ********** Code for DoubleLinkedQueue_ClassElement **************
+function DoubleLinkedQueue_ClassElement() {}
+$inherits(DoubleLinkedQueue_ClassElement, DoubleLinkedQueue);
+DoubleLinkedQueue_ClassElement.prototype.is$Collection_E = function(){return this;};
+DoubleLinkedQueue_ClassElement.prototype.is$Collection_Object = function(){return this;};
+DoubleLinkedQueue_ClassElement.prototype.is$Collection_Type = false;
+DoubleLinkedQueue_ClassElement.prototype.is$Iterable = function(){return this;};
+// ********** Code for DoubleLinkedQueue_E **************
+function DoubleLinkedQueue_E() {}
+$inherits(DoubleLinkedQueue_E, DoubleLinkedQueue);
+DoubleLinkedQueue_E.prototype.is$Collection_E = function(){return this;};
+DoubleLinkedQueue_E.prototype.is$Collection_Object = function(){return this;};
+DoubleLinkedQueue_E.prototype.is$Collection_Type = function(){return this;};
+DoubleLinkedQueue_E.prototype.is$Iterable = function(){return this;};
+// ********** Code for DoubleLinkedQueue_Element **************
+function DoubleLinkedQueue_Element() {}
+$inherits(DoubleLinkedQueue_Element, DoubleLinkedQueue);
+DoubleLinkedQueue_Element.prototype.is$Collection_E = function(){return this;};
+DoubleLinkedQueue_Element.prototype.is$Collection_Object = function(){return this;};
+DoubleLinkedQueue_Element.prototype.is$Collection_Type = false;
+DoubleLinkedQueue_Element.prototype.is$Iterable = function(){return this;};
+// ********** Code for DoubleLinkedQueue_KeyValuePair_K$V **************
+function DoubleLinkedQueue_KeyValuePair_K$V() {
   // Initializers done
-  this._sentinel = new _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V();
+  this._sentinel = new _DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V();
 }
-$inherits(DoubleLinkedQueue$KeyValuePair$K$V, DoubleLinkedQueue);
-DoubleLinkedQueue$KeyValuePair$K$V.prototype.is$Collection$E = function(){return this;};
-DoubleLinkedQueue$KeyValuePair$K$V.prototype.is$Collection$Object = function(){return this;};
-DoubleLinkedQueue$KeyValuePair$K$V.prototype.is$Collection$Type = false;
-DoubleLinkedQueue$KeyValuePair$K$V.prototype.is$Iterable = function(){return this;};
-DoubleLinkedQueue$KeyValuePair$K$V.prototype.addLast = function(value) {
+$inherits(DoubleLinkedQueue_KeyValuePair_K$V, DoubleLinkedQueue);
+DoubleLinkedQueue_KeyValuePair_K$V.prototype.is$Collection_E = function(){return this;};
+DoubleLinkedQueue_KeyValuePair_K$V.prototype.is$Collection_Object = function(){return this;};
+DoubleLinkedQueue_KeyValuePair_K$V.prototype.is$Collection_Type = false;
+DoubleLinkedQueue_KeyValuePair_K$V.prototype.is$Iterable = function(){return this;};
+DoubleLinkedQueue_KeyValuePair_K$V.prototype.addLast = function(value) {
   this._sentinel.prepend(value);
 }
-DoubleLinkedQueue$KeyValuePair$K$V.prototype.lastEntry = function() {
+DoubleLinkedQueue_KeyValuePair_K$V.prototype.lastEntry = function() {
   return this._sentinel.previousEntry();
 }
-DoubleLinkedQueue$KeyValuePair$K$V.prototype.forEach = function(f) {
+DoubleLinkedQueue_KeyValuePair_K$V.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while (entry !== this._sentinel) {
     var nextEntry = entry._next;
     f(entry._element);
     entry = nextEntry;
   }
 }
 // ********** Code for _DoubleLinkedQueueIterator **************
 function _DoubleLinkedQueueIterator(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
-_DoubleLinkedQueueIterator.prototype.is$Iterator$T = function(){return this;};
+_DoubleLinkedQueueIterator.prototype.is$Iterator_T = function(){return this;};
 _DoubleLinkedQueueIterator.prototype.hasNext = function() {
   return this._currentEntry._next !== this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$0/*const NoMoreElementsException()*/);
   }
   this._currentEntry = this._currentEntry._next;
   return this._currentEntry.get$element();
 }
 _DoubleLinkedQueueIterator.prototype.hasNext$0 = _DoubleLinkedQueueIterator.prototype.hasNext;
 _DoubleLinkedQueueIterator.prototype.next$0 = _DoubleLinkedQueueIterator.prototype.next;
-// ********** Code for _DoubleLinkedQueueIterator$E **************
-function _DoubleLinkedQueueIterator$E(_sentinel) {
+// ********** Code for _DoubleLinkedQueueIterator_E **************
+function _DoubleLinkedQueueIterator_E(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
-$inherits(_DoubleLinkedQueueIterator$E, _DoubleLinkedQueueIterator);
-_DoubleLinkedQueueIterator$E.prototype.is$Iterator$T = function(){return this;};
+$inherits(_DoubleLinkedQueueIterator_E, _DoubleLinkedQueueIterator);
+_DoubleLinkedQueueIterator_E.prototype.is$Iterator_T = function(){return this;};
 // ********** Code for StopwatchImplementation **************
 function StopwatchImplementation() {
   this._start = null;
   this._stop = null;
   // Initializers done
 }
 StopwatchImplementation.prototype.start = function() {
   if (this._start == null) {
     this._start = Clock.now();
   }
@@ skipping 63 matching lines @@
 StringBufferImpl.prototype.toString = function() {
   if (this._buffer.length == 0) return "";
   if (this._buffer.length == 1) return $assert_String(this._buffer.$index(0));
   var result = StringBase.concatAll(this._buffer);
   this._buffer.clear();
   this._buffer.add(result);
   return result;
 }
 StringBufferImpl.prototype.add$1 = StringBufferImpl.prototype.add;
 StringBufferImpl.prototype.addAll$1 = function($0) {
-  return this.addAll(($0 && $0.is$Collection$Object()));
+  return this.addAll(($0 && $0.is$Collection_Object()));
 };
 StringBufferImpl.prototype.isEmpty$0 = StringBufferImpl.prototype.isEmpty;
 StringBufferImpl.prototype.toString$0 = StringBufferImpl.prototype.toString;
 // ********** Code for StringBase **************
 function StringBase() {}
 StringBase.createFromCharCodes = function(charCodes) {
   if (Object.getPrototypeOf(charCodes) !== Array.prototype) {
     var length = charCodes.length;
     var tmp = new Array(length);
     for (var i = 0; i < length; i++) {
@@ skipping 253 matching lines @@
     if ($notnull_bool($eq(piece, '..')) && pieces.length > 0 && $notnull_bool($ne(pieces.last$0(), '.')) && $notnull_bool($ne(pieces.last$0(), '..'))) {
       pieces.removeLast$0();
     }
     else if ($notnull_bool($ne(piece, ''))) {
       if (pieces.length > 0 && $notnull_bool($eq(pieces.last$0(), '.'))) {
         pieces.removeLast$0();
       }
       pieces.add$1(piece);
     }
   }
-  return Strings.join((pieces && pieces.is$List$String()), '/');
+  return Strings.join((pieces && pieces.is$List_String()), '/');
 }
 function dirname(path) {
   var lastSlash = path.lastIndexOf('/', path.length);
   if (lastSlash == -1) {
     return '.';
   }
   else {
     return path.substring(0, lastSlash);
   }
 }
@@ skipping 24 matching lines @@
 //  ********** Library io **************
 // ********** Code for top level **************
 function join(strings) {
   return Strings.join(strings, '/');
 }
 //  ********** Library util_implementation **************
 // ********** Code for LinkFactory **************
 function LinkFactory() {}
 LinkFactory.Link$factory = function(head, tail) {
   if (tail == null) {
-    tail = new LinkTail$Dynamic();
+    tail = new LinkTail_T();
   }
-  return new LinkEntry$Dynamic(head, tail);
+  return new LinkEntry_T(head, tail);
 }
 // ********** Code for AbstractLink **************
 function AbstractLink() {
   // Initializers done
 }
-AbstractLink.prototype.is$Link$Element = function(){return this;};
-AbstractLink.prototype.is$Link$Node = function(){return this;};
-AbstractLink.prototype.is$Link$Token = function(){return this;};
-AbstractLink.prototype.is$Link$Type = function(){return this;};
+AbstractLink.prototype.is$Link_Element = function(){return this;};
+AbstractLink.prototype.is$Link_Node = 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");
 }
 AbstractLink.prototype.get$tail = function() {
   $throw("bug");
 }
 AbstractLink.prototype.prepend = function(element) {
-  return new LinkEntry$T(element, this);
+  return new LinkEntry_T(element, this);
 }
 AbstractLink.prototype.iterator = function() {
   var $0;
-  return (($0 = this.toList().iterator$0()) && $0.is$Iterator$T());
+  return (($0 = this.toList().iterator$0()) && $0.is$Iterator_T());
 }
 AbstractLink.prototype.printOn = function(buffer, separatedBy) {
   if ($notnull_bool(this.isEmpty())) return;
   buffer.add(this.get$head() == null ? 'null' : this.get$head());
   if (separatedBy == null) separatedBy = '';
   for (var link = this.get$tail();
    !$notnull_bool(link.isEmpty()); link = link.get$tail()) {
     buffer.add(separatedBy);
     buffer.add(link.get$head() == null ? 'null' : link.get$head());
   }
 }
 AbstractLink.prototype.toString = function() {
   var buffer = new StringBufferImpl("");
   buffer.add('[ ');
   this.printOn(buffer, ', ');
   buffer.add(' ]');
   return buffer.toString();
 }
 AbstractLink.prototype.isEmpty$0 = AbstractLink.prototype.isEmpty;
 AbstractLink.prototype.iterator$0 = AbstractLink.prototype.iterator;
 AbstractLink.prototype.printOn$1 = function($0) {
   return this.printOn(($0 && $0.is$StringBuffer()));
 };
 AbstractLink.prototype.toString$0 = AbstractLink.prototype.toString;
-// ********** Code for AbstractLink$Dynamic **************
-function AbstractLink$Dynamic() {
+// ********** Code for AbstractLink_T **************
+function AbstractLink_T() {
   // Initializers done
 }
-$inherits(AbstractLink$Dynamic, AbstractLink);
-AbstractLink$Dynamic.prototype.is$Link$Element = function(){return this;};
-AbstractLink$Dynamic.prototype.is$Link$Node = function(){return this;};
-AbstractLink$Dynamic.prototype.is$Link$Token = function(){return this;};
-AbstractLink$Dynamic.prototype.is$Link$Type = function(){return this;};
-AbstractLink$Dynamic.prototype.is$Iterable = function(){return this;};
-// ********** Code for AbstractLink$T **************
-function AbstractLink$T() {
-  // Initializers done
+$inherits(AbstractLink_T, AbstractLink);
+AbstractLink_T.prototype.is$Link_Element = function(){return this;};
+AbstractLink_T.prototype.is$Link_Node = 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.prepend = function(element) {
+  return new LinkEntry_T(element, this);
 }
-$inherits(AbstractLink$T, AbstractLink);
-AbstractLink$T.prototype.is$Link$Element = function(){return this;};
-AbstractLink$T.prototype.is$Link$Node = 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.prepend = function(element) {
-  return new LinkEntry$T(element, this);
+AbstractLink_T.prototype.iterator = function() {
+  var $0;
+  return (($0 = this.toList().iterator$0()) && $0.is$Iterator_T());
 }
-AbstractLink$T.prototype.iterator = function() {
-  var $0;
-  return (($0 = this.toList().iterator$0()) && $0.is$Iterator$T());
-}
-AbstractLink$T.prototype.printOn = function(buffer, separatedBy) {
+AbstractLink_T.prototype.printOn = function(buffer, separatedBy) {
   if ($notnull_bool(this.isEmpty())) return;
   buffer.add(this.get$head() == null ? 'null' : this.get$head());
   if (separatedBy == null) separatedBy = '';
   for (var link = this.get$tail();
    !$notnull_bool(link.isEmpty()); link = link.get$tail()) {
     buffer.add(separatedBy);
     buffer.add(link.get$head() == null ? 'null' : link.get$head());
   }
 }
-AbstractLink$T.prototype.toString = function() {
+AbstractLink_T.prototype.toString = function() {
   var buffer = new StringBufferImpl("");
   buffer.add('[ ');
   this.printOn(buffer, ', ');
   buffer.add(' ]');
   return buffer.toString();
 }
 // ********** Code for LinkTail **************
 function LinkTail() {
   // Initializers done
-  AbstractLink$T.call(this);
+  AbstractLink_T.call(this);
 }
-$inherits(LinkTail, AbstractLink$T);
-LinkTail.prototype.is$Link$Element = function(){return this;};
-LinkTail.prototype.is$Link$Node = function(){return this;};
-LinkTail.prototype.is$Link$Token = function(){return this;};
-LinkTail.prototype.is$Link$Type = function(){return this;};
+$inherits(LinkTail, AbstractLink_T);
+LinkTail.prototype.is$Link_Element = function(){return this;};
+LinkTail.prototype.is$Link_Node = 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() {
   return null;
 }
 LinkTail.prototype.get$tail = function() {
   return null;
 }
 LinkTail.prototype.toList = function() {
   return const$15/*const []*/;
 }
 LinkTail.prototype.isEmpty = function() {
   return true;
 }
 LinkTail.prototype.isEmpty$0 = LinkTail.prototype.isEmpty;
-// ********** Code for LinkTail$Dynamic **************
-function LinkTail$Dynamic() {
+// ********** Code for LinkTail_Element **************
+function LinkTail_Element() {}
+$inherits(LinkTail_Element, LinkTail);
+LinkTail_Element.prototype.is$Link_Element = function(){return this;};
+LinkTail_Element.prototype.is$Link_Node = false;
+LinkTail_Element.prototype.is$Link_Token = false;
+LinkTail_Element.prototype.is$Link_Type = false;
+LinkTail_Element.prototype.is$Iterable = function(){return this;};
+// ********** Code for LinkTail_Node **************
+function LinkTail_Node() {}
+$inherits(LinkTail_Node, LinkTail);
+LinkTail_Node.prototype.is$Link_Element = false;
+LinkTail_Node.prototype.is$Link_Node = function(){return this;};
+LinkTail_Node.prototype.is$Link_Token = false;
+LinkTail_Node.prototype.is$Link_Type = false;
+LinkTail_Node.prototype.is$Iterable = function(){return this;};
+// ********** Code for LinkTail_T **************
+function LinkTail_T() {
   // Initializers done
-  AbstractLink$Dynamic.call(this);
+  AbstractLink_T.call(this);
 }
-$inherits(LinkTail$Dynamic, LinkTail);
-LinkTail$Dynamic.prototype.is$Link$Element = function(){return this;};
-LinkTail$Dynamic.prototype.is$Link$Node = function(){return this;};
-LinkTail$Dynamic.prototype.is$Link$Token = function(){return this;};
-LinkTail$Dynamic.prototype.is$Link$Type = function(){return this;};
-LinkTail$Dynamic.prototype.is$Iterable = function(){return this;};
-// ********** Code for LinkTail$Element **************
-function LinkTail$Element() {}
-$inherits(LinkTail$Element, LinkTail);
-LinkTail$Element.prototype.is$Link$Element = function(){return this;};
-LinkTail$Element.prototype.is$Link$Node = false;
-LinkTail$Element.prototype.is$Link$Token = false;
-LinkTail$Element.prototype.is$Link$Type = false;
-LinkTail$Element.prototype.is$Iterable = function(){return this;};
-// ********** Code for LinkTail$Node **************
-function LinkTail$Node() {}
-$inherits(LinkTail$Node, LinkTail);
-LinkTail$Node.prototype.is$Link$Element = false;
-LinkTail$Node.prototype.is$Link$Node = function(){return this;};
-LinkTail$Node.prototype.is$Link$Token = false;
-LinkTail$Node.prototype.is$Link$Type = false;
-LinkTail$Node.prototype.is$Iterable = function(){return this;};
-// ********** Code for LinkTail$T **************
-function LinkTail$T() {}
-$inherits(LinkTail$T, LinkTail);
-LinkTail$T.prototype.is$Link$Element = function(){return this;};
-LinkTail$T.prototype.is$Link$Node = function(){return this;};
-LinkTail$T.prototype.is$Link$Token = function(){return this;};
-LinkTail$T.prototype.is$Link$Type = function(){return this;};
-LinkTail$T.prototype.is$Iterable = function(){return this;};
-// ********** Code for LinkTail$Token **************
-function LinkTail$Token() {}
-$inherits(LinkTail$Token, LinkTail);
-LinkTail$Token.prototype.is$Link$Element = false;
-LinkTail$Token.prototype.is$Link$Node = false;
-LinkTail$Token.prototype.is$Link$Token = function(){return this;};
-LinkTail$Token.prototype.is$Link$Type = false;
-LinkTail$Token.prototype.is$Iterable = function(){return this;};
-// ********** Code for LinkTail$Type **************
-function LinkTail$Type() {}
-$inherits(LinkTail$Type, LinkTail);
-LinkTail$Type.prototype.is$Link$Element = false;
-LinkTail$Type.prototype.is$Link$Node = false;
-LinkTail$Type.prototype.is$Link$Token = false;
-LinkTail$Type.prototype.is$Link$Type = function(){return this;};
-LinkTail$Type.prototype.is$Iterable = function(){return this;};
+$inherits(LinkTail_T, LinkTail);
+LinkTail_T.prototype.is$Link_Element = function(){return this;};
+LinkTail_T.prototype.is$Link_Node = function(){return this;};
+LinkTail_T.prototype.is$Link_Token = function(){return this;};
+LinkTail_T.prototype.is$Link_Type = function(){return this;};
+LinkTail_T.prototype.is$Iterable = function(){return this;};
+// ********** Code for LinkTail_Token **************
+function LinkTail_Token() {}
+$inherits(LinkTail_Token, LinkTail);
+LinkTail_Token.prototype.is$Link_Element = false;
+LinkTail_Token.prototype.is$Link_Node = false;
+LinkTail_Token.prototype.is$Link_Token = function(){return this;};
+LinkTail_Token.prototype.is$Link_Type = false;
+LinkTail_Token.prototype.is$Iterable = function(){return this;};
+// ********** Code for LinkTail_Type **************
+function LinkTail_Type() {}
+$inherits(LinkTail_Type, LinkTail);
+LinkTail_Type.prototype.is$Link_Element = false;
+LinkTail_Type.prototype.is$Link_Node = false;
+LinkTail_Type.prototype.is$Link_Token = false;
+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);
+  AbstractLink_T.call(this);
 }
-$inherits(LinkEntry, AbstractLink$T);
+$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 list = new ListFactory();
   for (var link = this;
    !$notnull_bool(link.isEmpty()); link = link.get$tail()) {
     list.addLast(link.get$head());
   }
   return list;
 }
 LinkEntry.prototype.isEmpty$0 = LinkEntry.prototype.isEmpty;
-// ********** Code for LinkEntry$Dynamic **************
-function LinkEntry$Dynamic(head, realTail) {
+// ********** Code for LinkEntry_T **************
+function LinkEntry_T(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
-  AbstractLink$Dynamic.call(this);
+  AbstractLink_T.call(this);
 }
-$inherits(LinkEntry$Dynamic, LinkEntry);
-// ********** 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);
+$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; };
 LinkBuilderImplementation.prototype.toLink = function() {
   if (this.head == null) return const$232/*const LinkTail()*/;
   this.lastLink.realTail = const$232/*const LinkTail()*/;
   var link = this.head;
   this.lastLink = null;
   this.head = null;
   return link;
 }
 LinkBuilderImplementation.prototype.addLast = function(t) {
-  var entry = new LinkEntry$T(t, null);
+  var entry = new LinkEntry_T(t, null);
   if (this.head == null) {
     this.head = entry;
   }
   else {
     this.lastLink.realTail = entry;
   }
   this.lastLink = entry;
 }
-// ********** Code for LinkBuilderImplementation$Element **************
-function LinkBuilderImplementation$Element() {}
-$inherits(LinkBuilderImplementation$Element, LinkBuilderImplementation);
-// ********** Code for LinkBuilderImplementation$T **************
-function LinkBuilderImplementation$T() {}
-$inherits(LinkBuilderImplementation$T, LinkBuilderImplementation);
-// ********** Code for LinkBuilderImplementation$Type **************
-function LinkBuilderImplementation$Type() {}
-$inherits(LinkBuilderImplementation$Type, LinkBuilderImplementation);
+// ********** Code for LinkBuilderImplementation_Element **************
+function LinkBuilderImplementation_Element() {}
+$inherits(LinkBuilderImplementation_Element, LinkBuilderImplementation);
+// ********** Code for LinkBuilderImplementation_T **************
+function LinkBuilderImplementation_T() {}
+$inherits(LinkBuilderImplementation_T, LinkBuilderImplementation);
+// ********** Code for LinkBuilderImplementation_Type **************
+function LinkBuilderImplementation_Type() {}
+$inherits(LinkBuilderImplementation_Type, LinkBuilderImplementation);
 // ********** Code for top level **************
 //  ********** Library util **************
 // ********** Code for top level **************
 //  ********** Library scanner_implementation **************
 // ********** Code for ArrayBasedScanner **************
 function ArrayBasedScanner() {
   this.groupingStack = const$16/*const EmptyLink<Token>()*/
   this.extraCharOffset = 0;
   this.tokenStart = -1;
   this.byteOffset = -1;
   this.tokens = new Token(0/*null.EOF_TOKEN*/, -1);
   // Initializers done
-  AbstractScanner$S.call(this);
+  AbstractScanner_S.call(this);
   this.tail = this.tokens;
 }
-$inherits(ArrayBasedScanner, AbstractScanner$S);
+$inherits(ArrayBasedScanner, AbstractScanner_S);
 ArrayBasedScanner.prototype.get$charOffset = function() {
   return this.byteOffset + this.extraCharOffset;
 }
 ArrayBasedScanner.prototype.get$byteOffset = function() { return this.byteOffset; };
 ArrayBasedScanner.prototype.set$byteOffset = function(value) { return this.byteOffset = value; };
 ArrayBasedScanner.prototype.advance = function() {
   var next = this.nextByte();
   return next;
 }
 ArrayBasedScanner.prototype.select = function(choice, yes, no) {
@@ skipping 30 matching lines @@
 }
 ArrayBasedScanner.prototype.appendWhiteSpace = function(next) {
 
 }
 ArrayBasedScanner.prototype.appendBeginGroup = function(kind, value) {
   var $0;
   var token = new BeginGroupToken(kind, value, this.tokenStart);
   this.tail.next = token;
   this.tail = this.tail.next;
   while (kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
-    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
+    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link_Token());
   }
-  this.groupingStack = (($0 = this.groupingStack.prepend(token)) && $0.is$Link$Token());
+  this.groupingStack = (($0 = this.groupingStack.prepend(token)) && $0.is$Link_Token());
 }
 ArrayBasedScanner.prototype.appendEndGroup = function(kind, value, openKind) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) {
     if (openKind === 60/*null.LT_TOKEN*/) return;
     $throw(new MalformedInputException(('Unmatched ' + value)));
   }
   while (openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
-    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
+    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link_Token());
   }
   if (this.groupingStack.get$head().get$kind() !== openKind) {
     if (openKind === 60/*null.LT_TOKEN*/) return;
     $throw(new MalformedInputException(('Unmatched ' + value)));
   }
   this.groupingStack.get$head().set$endGroup(oldTail.next);
-  this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
+  this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link_Token());
 }
 ArrayBasedScanner.prototype.appendGtGt = function(kind, value) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
   if (this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
-    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
+    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link_Token());
   }
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
   if (this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
     this.groupingStack.get$head().set$endGroup(oldTail.next);
-    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
+    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link_Token());
   }
 }
 ArrayBasedScanner.prototype.appendGtGtGt = function(kind, value) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
   if (this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
-    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
+    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link_Token());
   }
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
   if (this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
-    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
+    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link_Token());
   }
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
   if (this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
     this.groupingStack.get$head().set$endGroup(oldTail.next);
-    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
+    this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link_Token());
   }
 }
-// ********** Code for ArrayBasedScanner$SourceString **************
-function ArrayBasedScanner$SourceString() {
+// ********** Code for ArrayBasedScanner_SourceString **************
+function ArrayBasedScanner_SourceString() {
   this.groupingStack = const$16/*const EmptyLink<Token>()*/
   this.extraCharOffset = 0;
   this.tokenStart = -1;
   this.byteOffset = -1;
   this.tokens = new Token(0/*null.EOF_TOKEN*/, -1);
   // Initializers done
-  AbstractScanner$SourceString.call(this);
+  AbstractScanner_SourceString.call(this);
   this.tail = this.tokens;
 }
-$inherits(ArrayBasedScanner$SourceString, ArrayBasedScanner);
+$inherits(ArrayBasedScanner_SourceString, ArrayBasedScanner);
 // ********** Code for top level **************
 //  ********** Library scanner **************
 // ********** Code for AbstractScanner **************
 function AbstractScanner() {
   // Initializers done
 }
 AbstractScanner.prototype.tokenize = function() {
   var next = this.advance();
   while (next != 0/*null.$EOF*/) {
     next = this.bigSwitch(next);
@@ skipping 567 matching lines @@
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 AbstractScanner.prototype.appendByteStringToken$2 = function($0, $1) {
   return this.appendByteStringToken($assert_num($0), $1);
 };
-// ********** Code for AbstractScanner$S **************
-function AbstractScanner$S() {
+// ********** Code for AbstractScanner_S **************
+function AbstractScanner_S() {
   // Initializers done
 }
-$inherits(AbstractScanner$S, AbstractScanner);
-// ********** Code for AbstractScanner$SourceString **************
-function AbstractScanner$SourceString() {
+$inherits(AbstractScanner_S, AbstractScanner);
+// ********** Code for AbstractScanner_SourceString **************
+function AbstractScanner_SourceString() {
   // Initializers done
 }
-$inherits(AbstractScanner$SourceString, AbstractScanner);
-AbstractScanner$SourceString.prototype.tokenize = function() {
+$inherits(AbstractScanner_SourceString, AbstractScanner);
+AbstractScanner_SourceString.prototype.tokenize = function() {
   var next = this.advance();
   while (next != 0/*null.$EOF*/) {
     next = this.bigSwitch(next);
   }
   this.appendEofToken();
   return this.firstToken();
 }
-AbstractScanner$SourceString.prototype.bigSwitch = function(next) {
+AbstractScanner_SourceString.prototype.bigSwitch = function(next) {
   this.beginToken();
   if (next === 9/*null.$TAB*/ || next === 10/*null.$LF*/ || next === 13/*null.$CR*/ || next === 32/*null.$SPACE*/) {
     this.appendWhiteSpace(next);
     return this.advance();
   }
   if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
     return this.tokenizeKeywordOrIdentifier(next);
   }
   if ((65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || next === 95/*null.$_*/ || next === 36/*null.$DOLLAR*/) {
     return this.tokenizeIdentifier(next, this.get$byteOffset());
@@ skipping 103 matching lines @@
     return this.tokenizeNumber(next);
   }
   if (next === 0/*null.$EOF*/) {
     return 0/*null.$EOF*/;
   }
   if (next < 0x1f) {
     $throw(new MalformedInputException(this.get$charOffset()));
   }
   return this.tokenizeIdentifier(next, this.get$byteOffset());
 }
-AbstractScanner$SourceString.prototype.tokenizeTag = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeTag = function(next) {
   if (this.get$byteOffset() === 0) {
     if (this.peek() === 33/*null.$BANG*/) {
       do {
         next = this.advance();
       }
       while (next != 10/*null.$LF*/ && next != 13/*null.$CR*/)
       return next;
     }
   }
   this.appendStringToken(35/*null.HASH_TOKEN*/, "#");
   return this.advance();
 }
-AbstractScanner$SourceString.prototype.tokenizeTilde = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeTilde = function(next) {
   next = this.advance();
   if (next === 47/*null.$SLASH*/) {
     return this.select(61/*null.$EQ*/, "~/=", "~/");
   }
   else {
     this.appendStringToken(126/*null.TILDE_TOKEN*/, "~");
     return next;
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeOpenBracket = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeOpenBracket = function(next) {
   next = this.advance();
   if (next === 93/*null.$RBRACKET*/) {
     return this.select(61/*null.$EQ*/, "[]=", "[]");
   }
   else {
     this.appendBeginGroup(91/*null.LBRACKET_TOKEN*/, "[");
     return next;
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeCaret = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeCaret = function(next) {
   return this.select(61/*null.$EQ*/, "^=", "^");
 }
-AbstractScanner$SourceString.prototype.tokenizeBar = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeBar = function(next) {
   next = this.advance();
   if (next === 124/*null.$BAR*/) {
     this.appendStringToken(124/*null.BAR_TOKEN*/, "||");
     return this.advance();
   }
   else if (next === 61/*null.$EQ*/) {
     this.appendStringToken(124/*null.BAR_TOKEN*/, "|=");
     return this.advance();
   }
   else {
     this.appendStringToken(124/*null.BAR_TOKEN*/, "|");
     return next;
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeAmpersand = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeAmpersand = function(next) {
   next = this.advance();
   if (next === 38/*null.$AMPERSAND*/) {
     this.appendStringToken(38/*null.AMPERSAND_TOKEN*/, "&&");
     return this.advance();
   }
   else if (next === 61/*null.$EQ*/) {
     this.appendStringToken(38/*null.AMPERSAND_TOKEN*/, "&=");
     return this.advance();
   }
   else {
     this.appendStringToken(38/*null.AMPERSAND_TOKEN*/, "&");
     return next;
   }
 }
-AbstractScanner$SourceString.prototype.tokenizePercent = function(next) {
+AbstractScanner_SourceString.prototype.tokenizePercent = function(next) {
   return this.select(61/*null.$EQ*/, "%=", "%");
 }
-AbstractScanner$SourceString.prototype.tokenizeMultiply = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeMultiply = function(next) {
   return this.select(61/*null.$EQ*/, "*=", "*");
 }
-AbstractScanner$SourceString.prototype.tokenizeMinus = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeMinus = function(next) {
   next = this.advance();
   if (next === 45/*null.$MINUS*/) {
     this.appendStringToken(45/*null.MINUS_TOKEN*/, "--");
     return this.advance();
   }
   else if (next === 61/*null.$EQ*/) {
     this.appendStringToken(45/*null.MINUS_TOKEN*/, "-=");
     return this.advance();
   }
   else {
     this.appendStringToken(45/*null.MINUS_TOKEN*/, "-");
     return next;
   }
 }
-AbstractScanner$SourceString.prototype.tokenizePlus = function(next) {
+AbstractScanner_SourceString.prototype.tokenizePlus = function(next) {
   next = this.advance();
   if (43/*null.$PLUS*/ === next) {
     this.appendStringToken(43/*null.PLUS_TOKEN*/, "++");
     return this.advance();
   }
   else if (61/*null.$EQ*/ === next) {
     this.appendStringToken(43/*null.PLUS_TOKEN*/, "+=");
     return this.advance();
   }
   else {
     this.appendStringToken(43/*null.PLUS_TOKEN*/, "+");
     return next;
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeExclamation = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeExclamation = function(next) {
   next = this.advance();
   if (next === 61/*null.$EQ*/) {
     return this.select(61/*null.$EQ*/, "!==", "!=");
   }
   this.appendStringToken(33/*null.BANG_TOKEN*/, "!");
   return next;
 }
-AbstractScanner$SourceString.prototype.tokenizeEquals = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeEquals = function(next) {
   next = this.advance();
   if (next === 61/*null.$EQ*/) {
     return this.select(61/*null.$EQ*/, "===", "==");
   }
   this.appendStringToken(61/*null.EQ_TOKEN*/, "=");
   return next;
 }
-AbstractScanner$SourceString.prototype.tokenizeGreaterThan = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeGreaterThan = function(next) {
   next = this.advance();
   if (61/*null.$EQ*/ === next) {
     this.appendStringToken(62/*null.GT_TOKEN*/, ">=");
     return this.advance();
   }
   else if (62/*null.$GT*/ === next) {
     next = this.advance();
     if (61/*null.$EQ*/ === next) {
       this.appendStringToken(62/*null.GT_TOKEN*/, ">>=");
       return this.advance();
@@ skipping 12 matching lines @@
     else {
       this.appendGtGt(62/*null.GT_TOKEN*/, ">>");
       return next;
     }
   }
   else {
     this.appendEndGroup(62/*null.GT_TOKEN*/, ">", 60/*null.LT_TOKEN*/);
     return next;
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeLessThan = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeLessThan = function(next) {
   next = this.advance();
   if (61/*null.$EQ*/ === next) {
     this.appendStringToken(188/*null.LT_EQ_TOKEN*/, "<=");
     return this.advance();
   }
   else if (60/*null.$LT*/ === next) {
     return this.select(61/*null.$EQ*/, "<<=", "<<");
   }
   else {
     this.appendBeginGroup(60/*null.LT_TOKEN*/, "<");
     return next;
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeNumber = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeNumber = function(next) {
   var start = this.get$byteOffset();
   while (true) {
     next = this.advance();
     if (48/*null.$0*/ <= next && next <= 57/*null.$9*/) {
       continue;
     }
     else if (next === 46/*null.$PERIOD*/) {
       return this.tokenizeFractionPart(this.advance(), start);
     }
     else if (next === 101/*null.$e*/ || next === 69/*null.$E*/ || next === 100/*null.$d*/ || next === 68/*null.$D*/) {
       return this.tokenizeFractionPart(next, start);
     }
     else {
       this.appendByteStringToken(105/*null.INT_TOKEN*/, this.asciiString(start));
       return next;
     }
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeHexOrNumber = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeHexOrNumber = function(next) {
   var x = this.peek();
   if (x === 120/*null.$x*/ || x === 88/*null.$X*/) {
     this.advance();
     return this.tokenizeHex(x);
   }
   return this.tokenizeNumber(next);
 }
-AbstractScanner$SourceString.prototype.tokenizeHex = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeHex = function(next) {
   var start = this.get$byteOffset();
   var hasDigits = false;
   while (true) {
     next = this.advance();
     if ((48/*null.$0*/ <= next && next <= 57/*null.$9*/) || (65/*null.$A*/ <= next && next <= 70/*null.$F*/) || (97/*null.$a*/ <= next && next <= 102/*null.$f*/)) {
       hasDigits = true;
     }
     else {
       if (!$notnull_bool(hasDigits)) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       this.appendByteStringToken(120/*null.HEXADECIMAL_TOKEN*/, this.asciiString(start));
       return next;
     }
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeDotOrNumber = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeDotOrNumber = function(next) {
   var start = this.get$byteOffset();
   next = this.advance();
   if ((48/*null.$0*/ <= next && next <= 57/*null.$9*/)) {
     return this.tokenizeFractionPart(next, start);
   }
   else if (46/*null.$PERIOD*/ === next) {
     return this.select(46/*null.$PERIOD*/, "...", "..");
   }
   else {
     this.appendStringToken(46/*null.PERIOD_TOKEN*/, ".");
     return next;
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeFractionPart = function(next, start) {
+AbstractScanner_SourceString.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
   while (!$notnull_bool(done)) {
     if (48/*null.$0*/ <= next && next <= 57/*null.$9*/) {
     }
     else if (101/*null.$e*/ === next || 69/*null.$E*/ === next) {
       next = this.tokenizeExponent(this.advance());
       done = true;
       continue LOOP;
     }
     else {
       done = true;
       continue LOOP;
     }
     next = this.advance();
   }
   if (next === 100/*null.$d*/ || next === 68/*null.$D*/) {
     next = this.advance();
   }
   this.appendByteStringToken(100/*null.DOUBLE_TOKEN*/, this.asciiString(start));
   return next;
 }
-AbstractScanner$SourceString.prototype.tokenizeExponent = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeExponent = function(next) {
   if (next === 43/*null.$PLUS*/ || next === 45/*null.$MINUS*/) {
     next = this.advance();
   }
   var hasDigits = false;
   while (true) {
     if (48/*null.$0*/ <= next && next <= 57/*null.$9*/) {
       hasDigits = true;
     }
     else {
       if (!$notnull_bool(hasDigits)) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return next;
     }
     next = this.advance();
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeSlashOrComment = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
   if (42/*null.$STAR*/ === next) {
     return this.tokenizeMultiLineComment(next);
   }
   else if (47/*null.$SLASH*/ === next) {
     return this.tokenizeSingleLineComment(next);
   }
   else if (61/*null.$EQ*/ === next) {
     this.appendStringToken(47/*null.SLASH_TOKEN*/, "/=");
     return this.advance();
   }
   else {
     this.appendStringToken(47/*null.SLASH_TOKEN*/, "/");
     return next;
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeSingleLineComment = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeSingleLineComment = function(next) {
   while (true) {
     next = this.advance();
     if (10/*null.$LF*/ === next || 13/*null.$CR*/ === next || 0/*null.$EOF*/ === next) {
       return next;
     }
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeMultiLineComment = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
   while (true) {
     if (0/*null.$EOF*/ === next) {
       return next;
     }
     else if (42/*null.$STAR*/ === next) {
       next = this.advance();
       if (next === 47/*null.$SLASH*/) {
         return this.advance();
       }
       else if (next === 0/*null.$EOF*/) {
         return next;
       }
     }
     else {
       next = this.advance();
     }
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeKeywordOrIdentifier = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeKeywordOrIdentifier = function(next) {
   var state = KeywordState.get$KEYWORD_STATE();
   var start = this.get$byteOffset();
   while (state != null && 97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
     state = state.next(next);
     next = this.advance();
   }
   if (state == null || !$notnull_bool(state.isLeaf())) {
     return this.tokenizeIdentifier(next, start);
   }
   if ((65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || (48/*null.$0*/ <= next && next <= 57/*null.$9*/) || next === 95/*null.$_*/ || next === 36/*null.$DOLLAR*/) {
     return this.tokenizeIdentifier(next, start);
   }
   else if (next < 128) {
     this.appendKeywordToken(state.get$keyword());
     return next;
   }
   else {
     return this.tokenizeIdentifier(next, start);
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeIdentifier = function(next, start) {
+AbstractScanner_SourceString.prototype.tokenizeIdentifier = function(next, start) {
   var isAscii = true;
   while (true) {
     if ((97/*null.$a*/ <= next && next <= 122/*null.$z*/) || (65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || (48/*null.$0*/ <= next && next <= 57/*null.$9*/) || next === 95/*null.$_*/ || next === 36/*null.$DOLLAR*/) {
       next = this.advance();
     }
     else if (next < 128) {
       if ($notnull_bool(isAscii)) {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.asciiString(start));
       }
       else {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.utf8String(start, -1));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.get$byteOffset();
       do {
         next = this.nextByte();
       }
       while (next > 127)
       var string = this.utf8String(nonAsciiStart, -1).toString();
       isAscii = false;
       var byteLength = nonAsciiStart - this.get$byteOffset();
       this.addToCharOffset(string.length - byteLength);
     }
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeRawString = function(next) {
+AbstractScanner_SourceString.prototype.tokenizeRawString = function(next) {
   var start = this.get$byteOffset();
   next = this.advance();
   if (next === 34/*null.$DQ*/ || next === 39/*null.$SQ*/) {
     return this.tokenizeString(next, start, true);
   }
   else {
     $throw(new MalformedInputException(this.get$charOffset()));
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeString = function(next, start, raw) {
+AbstractScanner_SourceString.prototype.tokenizeString = function(next, start, raw) {
   var q = next;
   next = this.advance();
   if (q === next) {
     next = this.advance();
     if (q === next) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, -1));
       return next;
     }
   }
   if ($notnull_bool(raw)) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
-AbstractScanner$SourceString.prototype.tokenizeSingleLineString = function(next, q1, start) {
+AbstractScanner_SourceString.prototype.tokenizeSingleLineString = function(next, q1, start) {
   while (next != 0/*null.$EOF*/) {
     if (next === q1) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next === 92/*null.$BACKSLASH*/) {
       next = this.advance();
       if (next === 0/*null.$EOF*/) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
     }
     else if (next === 10/*null.$LF*/ || next === 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
-AbstractScanner$SourceString.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
+AbstractScanner_SourceString.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
   while (next != 0/*null.$EOF*/) {
     if (next === q1) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next === 10/*null.$LF*/ || next === 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
-AbstractScanner$SourceString.prototype.tokenizeMultiLineString = function(q, start, raw) {
+AbstractScanner_SourceString.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
   while (next != 0/*null.$EOF*/) {
     if (next === q) {
       next = this.advance();
       if (next === q) {
         next = this.advance();
         if (next === q) {
           this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
           return this.advance();
         }
@@ skipping 20 matching lines @@
 $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());
     for (var link = elements;
-     !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Element())) {
+     !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Element())) {
       $this.compiler.universe.define((($0 = link.get$head()) && $0.is$Element()));
     }
   })
   );
 }
 ScannerTask.prototype.scanElements = function(text) {
   var tokens = new StringScanner(text).tokenize();
   var listener = new ElementListener(this.compiler);
   var parser = new PartialParser(listener);
   parser.parseUnit(tokens);
@@ skipping 1527 matching lines @@
   this.canceler.cancel(("Expected a type, but got '" + token + "'"), null, token);
 }
 ElementListener.prototype.expectedBlock = function(token) {
   this.canceler.cancel(("Expected a block, but got '" + token + "'"), null, token);
 }
 ElementListener.prototype.unexpected = function(token) {
   this.canceler.cancel(("Unexpected token '" + token + "'"), null, token);
 }
 ElementListener.prototype.pushElement = function(element) {
   var $0;
-  this.topLevelElements = (($0 = this.topLevelElements.prepend(element)) && $0.is$Link$Element());
+  this.topLevelElements = (($0 = this.topLevelElements.prepend(element)) && $0.is$Link_Element());
 }
 ElementListener.prototype.pushNode = function(node) {
   var $0;
-  this.nodes = (($0 = this.nodes.prepend(node)) && $0.is$Link$Node());
+  this.nodes = (($0 = this.nodes.prepend(node)) && $0.is$Link_Node());
   if (false/*null.VERBOSE*/) this.log(("push " + this.nodes));
 }
 ElementListener.prototype.popNode = function() {
   var $0;
   $assert(!$notnull_bool(this.nodes.isEmpty()), "!nodes.isEmpty()", "listener.dart", 346, 12);
   var node = (($0 = this.nodes.get$head()) && $0.is$Node());
-  this.nodes = (($0 = this.nodes.get$tail()) && $0.is$Link$Node());
+  this.nodes = (($0 = this.nodes.get$tail()) && $0.is$Link_Node());
   if (false/*null.VERBOSE*/) this.log(("pop " + this.nodes));
   return node;
 }
 ElementListener.prototype.log = function(message) {
 
 }
 ElementListener.prototype.beginLibraryTag$1 = function($0) {
   return this.beginLibraryTag(($0 && $0.is$Token()));
 };
 ElementListener.prototype.endClass$5 = function($0, $1, $2, $3, $4) {
@@ skipping 199 matching lines @@
 NodeListener.prototype.handleUnaryPostfixExpression = function(token) {
   this.pushNode(new Send.postfix$ctor(this.popNode(), new Operator(token)));
 }
 NodeListener.prototype.handleUnaryPrefixExpression = function(token) {
   this.pushNode(new Send.prefix$ctor(this.popNode(), new Operator(token)));
 }
 NodeListener.prototype.makeNodeList = function(count, beginToken, endToken, delimiter) {
   var $0;
   var nodes = const$202/*const EmptyLink<Node>()*/;
   for (; count > 0; --count) {
-    nodes = (($0 = nodes.prepend(this.popNode())) && $0.is$Link$Node());
+    nodes = (($0 = nodes.prepend(this.popNode())) && $0.is$Link_Node());
   }
   var sourceDelimiter = (($0 = (delimiter == null) ? null : new StringWrapper(delimiter)) && $0.is$SourceString());
   return new NodeList(beginToken, nodes, endToken, sourceDelimiter);
 }
 NodeListener.prototype.log = function(message) {
   this.logger.log(message);
 }
 NodeListener.prototype.endArguments$3 = function($0, $1, $2) {
   return this.endArguments($assert_num($0), ($1 && $1.is$Token()), ($2 && $2.is$Token()));
 };
@@ skipping 117 matching lines @@
   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);
+  ArrayBasedScanner_SourceString.call(this);
 }
-$inherits(StringScanner, ArrayBasedScanner$SourceString);
+$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)) : 0/*null.$EOF*/;
 }
 StringScanner.prototype.asciiString = function(start) {
@@ skipping 188 matching lines @@
     strings.sort((function (a, b) {
       return a.compareTo$1(b);
     })
     );
     $globals.KeywordState__KEYWORD_STATE = KeywordState.computeKeywordStateTable(0, strings, 0, $assert_num(strings.length));
   }
   return $globals.KeywordState__KEYWORD_STATE;
 }
 KeywordState.computeKeywordStateTable = function(start, strings, offset, length) {
   var result = new ListFactory(26);
-  $assert(length != 0, "length != 0", "keyword.dart", 162, 12);
+  $assert(length != 0, "length != 0", "keyword.dart", 161, 12);
   var chunk = 0;
   var chunkStart = -1;
   for (var i = offset;
    i < offset + length; i++) {
     if (strings.$index(i).length > start) {
       var c = $assert_num(strings.$index(i).charCodeAt$1(start));
       if (chunk != c) {
         if (chunkStart != -1) {
           result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart));
         }
         chunkStart = i;
         chunk = c;
       }
     }
   }
   if (chunkStart != -1) {
     result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, offset + length - chunkStart));
   }
   else {
-    $assert(length == 1, "length == 1", "keyword.dart", 184, 14);
+    $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);
 }
@@ skipping 222 matching lines @@
 }
 SendSet.prototype.copyWithReceiver = function(receiver) {
   $throw('not implemented');
 }
 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;
+  this._nodes = nodes;
   // Initializers done
   Node.call(this);
 }
 NodeList.singleton$ctor = function(node) {
   // Initializers done
   NodeList.call(this, null, LinkFactory.Link$factory(node));
 }
 NodeList.singleton$ctor.prototype = NodeList.prototype;
 $inherits(NodeList, Node);
 NodeList.prototype.is$NodeList = function(){return this;};
 NodeList.prototype.get$nodes = function() {
   var $0;
-  return (($0 = this._nodes != null ? this._nodes : const$202/*const EmptyLink<Node>()*/) && $0.is$Link$Node());
+  return (($0 = this._nodes != null ? this._nodes : const$202/*const EmptyLink<Node>()*/) && $0.is$Link_Node());
 }
 NodeList.prototype.accept = function(visitor) {
   return visitor.visitNodeList(this);
 }
 NodeList.prototype.getBeginToken = function() {
   var $0;
   if (this.beginToken != null) return this.beginToken;
   if (this.get$nodes() != null) {
     for (var link = this.get$nodes();
-     !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+     !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
       if (link.get$head().getBeginToken$0() != null) {
         return (($0 = link.get$head().getBeginToken$0()) && $0.is$Token());
       }
       if (link.get$head().getEndToken$0() != null) {
         return (($0 = link.get$head().getEndToken$0()) && $0.is$Token());
       }
     }
   }
   return this.endToken;
 }
 NodeList.prototype.getEndToken = function() {
   var $0;
   if (this.endToken != null) return this.endToken;
   if (this.get$nodes() != null) {
     var link = this.get$nodes();
     if ($notnull_bool(link.isEmpty())) return this.beginToken;
-    while (!$notnull_bool(link.get$tail().isEmpty$0())) link = (($0 = link.get$tail()) && $0.is$Link$Node());
+    while (!$notnull_bool(link.get$tail().isEmpty$0())) link = (($0 = link.get$tail()) && $0.is$Link_Node());
     if (link.get$head().getEndToken$0() != null) return (($0 = link.get$head().getEndToken$0()) && $0.is$Token());
     if (link.get$head().getBeginToken$0() != null) return (($0 = link.get$head().getBeginToken$0()) && $0.is$Token());
   }
   return this.beginToken;
 }
 NodeList.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 NodeList.prototype.getBeginToken$0 = NodeList.prototype.getBeginToken;
 NodeList.prototype.getEndToken$0 = NodeList.prototype.getEndToken;
@@ skipping 112 matching lines @@
 }
 $inherits(Literal, Expression);
 Literal.prototype.getBeginToken = function() {
   return this.token;
 }
 Literal.prototype.getEndToken = function() {
   return this.token;
 }
 Literal.prototype.getBeginToken$0 = Literal.prototype.getBeginToken;
 Literal.prototype.getEndToken$0 = Literal.prototype.getEndToken;
-// ********** Code for Literal$SourceString **************
-function Literal$SourceString(token, handler) {
+// ********** 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) {
+$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) {
+$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) {
+$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);
+$inherits(Literal_int, Literal);
 // ********** Code for LiteralInt **************
 function LiteralInt(token, handler) {
   // Initializers done
-  Literal$int.call(this, token, handler);
+  Literal_int.call(this, token, handler);
 }
-$inherits(LiteralInt, Literal$int);
+$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);
+  Literal_double.call(this, token, handler);
 }
-$inherits(LiteralDouble, Literal$double);
+$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);
+  Literal_bool.call(this, token, handler);
 }
-$inherits(LiteralBool, Literal$bool);
+$inherits(LiteralBool, Literal_bool);
 LiteralBool.prototype.get$value = function() {
   switch (this.token.get$value()) {
     case const$69/*Keyword.TRUE*/:
 
       return true;
 
     case const$41/*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));
+  Literal_SourceString.call(this, token, to$call$2(null));
 }
-$inherits(LiteralString, Literal$SourceString);
+$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 LiteralNull **************
 function LiteralNull(token) {
   // Initializers done
-  Literal$SourceString.call(this, token, to$call$2(null));
+  Literal_SourceString.call(this, token, to$call$2(null));
 }
-$inherits(LiteralNull, Literal$SourceString);
+$inherits(LiteralNull, Literal_SourceString);
 LiteralNull.prototype.get$value = function() {
   return null;
 }
 LiteralNull.prototype.accept = function(visitor) {
   return visitor.visitLiteralNull(this);
 }
 LiteralNull.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 // ********** Code for Identifier **************
@@ skipping 345 matching lines @@
 }
 AbstractVisitor.prototype.visitLiteral = function(node) {
   return this.visitExpression(node);
 }
 AbstractVisitor.prototype.visitSend = function(node) {
   return this.visitExpression(node);
 }
 AbstractVisitor.prototype.visitStatement = function(node) {
   return this.visitNode(node);
 }
-// ********** Code for AbstractVisitor$Element **************
-function AbstractVisitor$Element() {
+// ********** Code for AbstractVisitor_Element **************
+function AbstractVisitor_Element() {
   // Initializers done
 }
-$inherits(AbstractVisitor$Element, AbstractVisitor);
-AbstractVisitor$Element.prototype.is$Visitor = function(){return this;};
-AbstractVisitor$Element.prototype.visitClassNode = function(node) {
+$inherits(AbstractVisitor_Element, AbstractVisitor);
+AbstractVisitor_Element.prototype.is$Visitor = function(){return this;};
+AbstractVisitor_Element.prototype.visitClassNode = function(node) {
   var $0;
   return (($0 = this.visitNode(node)) && $0.is$Element());
 }
-AbstractVisitor$Element.prototype.visitTypeAnnotation = function(node) {
+AbstractVisitor_Element.prototype.visitTypeAnnotation = function(node) {
   var $0;
   return (($0 = this.visitNode(node)) && $0.is$Element());
 }
-// ********** Code for AbstractVisitor$SourceString **************
-function AbstractVisitor$SourceString() {
+// ********** Code for AbstractVisitor_SourceString **************
+function AbstractVisitor_SourceString() {
   // Initializers done
 }
-$inherits(AbstractVisitor$SourceString, AbstractVisitor);
-AbstractVisitor$SourceString.prototype.is$Visitor = function(){return this;};
-// ********** Code for AbstractVisitor$Type **************
-function AbstractVisitor$Type() {
+$inherits(AbstractVisitor_SourceString, AbstractVisitor);
+AbstractVisitor_SourceString.prototype.is$Visitor = function(){return this;};
+// ********** Code for AbstractVisitor_Type **************
+function AbstractVisitor_Type() {
   // Initializers done
 }
-$inherits(AbstractVisitor$Type, AbstractVisitor);
-AbstractVisitor$Type.prototype.is$Visitor = function(){return this;};
-AbstractVisitor$Type.prototype.visitBlock = function(node) {
+$inherits(AbstractVisitor_Type, AbstractVisitor);
+AbstractVisitor_Type.prototype.is$Visitor = function(){return this;};
+AbstractVisitor_Type.prototype.visitBlock = function(node) {
   return this.visitStatement(node);
 }
-AbstractVisitor$Type.prototype.visitExpression = function(node) {
+AbstractVisitor_Type.prototype.visitExpression = function(node) {
   var $0;
   return (($0 = this.visitNode(node)) && $0.is$Type());
 }
-AbstractVisitor$Type.prototype.visitExpressionStatement = function(node) {
+AbstractVisitor_Type.prototype.visitExpressionStatement = function(node) {
   return this.visitStatement(node);
 }
-AbstractVisitor$Type.prototype.visitFor = function(node) {
+AbstractVisitor_Type.prototype.visitFor = function(node) {
   return this.visitStatement(node);
 }
-AbstractVisitor$Type.prototype.visitFunctionExpression = function(node) {
+AbstractVisitor_Type.prototype.visitFunctionExpression = function(node) {
   return this.visitExpression(node);
 }
-AbstractVisitor$Type.prototype.visitIdentifier = function(node) {
+AbstractVisitor_Type.prototype.visitIdentifier = function(node) {
   return this.visitExpression(node);
 }
-AbstractVisitor$Type.prototype.visitIf = function(node) {
+AbstractVisitor_Type.prototype.visitIf = function(node) {
   return this.visitStatement(node);
 }
-AbstractVisitor$Type.prototype.visitLiteral = function(node) {
+AbstractVisitor_Type.prototype.visitLiteral = function(node) {
   return this.visitExpression(node);
 }
-AbstractVisitor$Type.prototype.visitLiteralBool = function(node) {
+AbstractVisitor_Type.prototype.visitLiteralBool = function(node) {
   return this.visitLiteral(node);
 }
-AbstractVisitor$Type.prototype.visitLiteralDouble = function(node) {
+AbstractVisitor_Type.prototype.visitLiteralDouble = function(node) {
   return this.visitLiteral(node);
 }
-AbstractVisitor$Type.prototype.visitLiteralInt = function(node) {
+AbstractVisitor_Type.prototype.visitLiteralInt = function(node) {
   return this.visitLiteral(node);
 }
-AbstractVisitor$Type.prototype.visitLiteralNull = function(node) {
+AbstractVisitor_Type.prototype.visitLiteralNull = function(node) {
   return this.visitLiteral(node);
 }
-AbstractVisitor$Type.prototype.visitLiteralString = function(node) {
+AbstractVisitor_Type.prototype.visitLiteralString = function(node) {
   return this.visitLiteral(node);
 }
-AbstractVisitor$Type.prototype.visitNodeList = function(node) {
+AbstractVisitor_Type.prototype.visitNodeList = function(node) {
   var $0;
   return (($0 = this.visitNode(node)) && $0.is$Type());
 }
-AbstractVisitor$Type.prototype.visitOperator = function(node) {
+AbstractVisitor_Type.prototype.visitOperator = function(node) {
   var $0;
   return (($0 = this.visitIdentifier(node)) && $0.is$Type());
 }
-AbstractVisitor$Type.prototype.visitReturn = function(node) {
+AbstractVisitor_Type.prototype.visitReturn = function(node) {
   return this.visitStatement(node);
 }
-AbstractVisitor$Type.prototype.visitSend = function(node) {
+AbstractVisitor_Type.prototype.visitSend = function(node) {
   return this.visitExpression(node);
 }
-AbstractVisitor$Type.prototype.visitSendSet = function(node) {
+AbstractVisitor_Type.prototype.visitSendSet = function(node) {
   return this.visitSend(node);
 }
-AbstractVisitor$Type.prototype.visitStatement = function(node) {
+AbstractVisitor_Type.prototype.visitStatement = function(node) {
   var $0;
   return (($0 = this.visitNode(node)) && $0.is$Type());
 }
-AbstractVisitor$Type.prototype.visitThrow = function(node) {
+AbstractVisitor_Type.prototype.visitThrow = function(node) {
   return this.visitStatement(node);
 }
-AbstractVisitor$Type.prototype.visitVariableDefinitions = function(node) {
+AbstractVisitor_Type.prototype.visitVariableDefinitions = function(node) {
   return this.visitStatement(node);
 }
 // ********** Code for top level **************
 function firstBeginToken(first, second) {
   var $0;
   return (($0 = (first != null) ? first.getBeginToken() : second.getBeginToken()) && $0.is$Token());
 }
 //  ********** Library elements **************
 // ********** Code for ElementKind **************
 function ElementKind(id) {
   this.id = id;
   // Initializers done
 }
 ElementKind.prototype.get$id = function() { return this.id; };
 ElementKind.prototype.toString = function() {
   return this.id;
 }
 ElementKind.prototype.toString$0 = ElementKind.prototype.toString;
 // ********** Code for Element **************
 function Element(name, kind, enclosingElement) {
   this.name = name;
   this.kind = kind;
   this.enclosingElement = enclosingElement;
   // Initializers done
 }
 Element.prototype.is$Element = function(){return this;};
 Element.prototype.get$name = function() { return this.name; };
 Element.prototype.get$kind = function() { return this.kind; };
+Element.prototype.get$enclosingElement = function() { return this.enclosingElement; };
 Element.prototype.hashCode = function() {
   return this.name.hashCode();
 }
 Element.prototype.computeType$2 = function($0, $1) {
   return this.computeType(($0 && $0.is$Compiler()), ($1 && $1.is$Types()));
 };
 Element.prototype.hashCode$0 = Element.prototype.hashCode;
 // ********** Code for VariableElement **************
 function VariableElement(node, typeAnnotation, kind, name, enclosingElement) {
   this.node = node;
@@ skipping 41 matching lines @@
 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());
   if (this.parameters == null) compiler.resolveSignature(this);
   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 = this.parameters;
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Element())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Element())) {
     parameterTypes.addLast(link.get$head().computeType$2(compiler, types));
   }
-  this.type = new FunctionType(returnType, (($0 = parameterTypes.toLink()) && $0.is$Link$Type()));
+  this.type = new FunctionType(returnType, (($0 = parameterTypes.toLink()) && $0.is$Link_Type()));
   return (($0 = this.type) && $0.is$FunctionType());
 }
 FunctionElement.prototype.computeType$2 = function($0, $1) {
   return this.computeType(($0 && $0.is$Compiler()), $1);
 };
 // ********** Code for ClassElement **************
 function ClassElement(name) {
   this.interfaces = const$205/*const EmptyLink<Type>()*/
   this.isResolved = false
   // Initializers done
@@ skipping 124 matching lines @@
   }
   return value;
 }
 SsaBuilder.prototype.visit = function(node) {
   if (node != null) node.accept(this);
 }
 SsaBuilder.prototype.visitParameterValues = function(parameters) {
   var $0;
   var parameterIndex = 0;
   for (var link = parameters.get$nodes();
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     var container = (($0 = link.get$head()) && $0.is$VariableDefinitions());
     var identifierLink = container.definitions.get$nodes();
     $assert(!$notnull_bool(identifierLink.isEmpty()) && $notnull_bool(identifierLink.get$tail().isEmpty$0()), "!identifierLink.isEmpty() && identifierLink.tail.isEmpty()", "builder.dart", 130, 14);
     if (!(identifierLink.get$head() instanceof Identifier)) {
       this.compiler.unimplemented("SsaBuilder.visitParameterValues non-identifier");
     }
     var parameterId = (($0 = identifierLink.get$head()) && $0.is$Identifier());
     var element = (($0 = this.elements.$index(parameterId)) && $0.is$VariableElement());
     var parameter = new HParameterValue(element);
     this.add(parameter);
     this.definitions.$setindex(element, this.guard(element.type, parameter));
   }
 }
 SsaBuilder.prototype.visitBlock = function(node) {
   var $0;
   for (var link = node.statements.get$nodes();
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
     if ($notnull_bool(this.isAborted())) {
       if (!this.stack.isEmpty()) this.compiler.cancel('non-empty instruction stack');
       return;
     }
   }
   $assert(!$notnull_bool(this.current.isClosed()), "!current.isClosed()", "builder.dart", 153, 12);
   if (!this.stack.isEmpty()) this.compiler.cancel('non-empty instruction stack');
 }
 SsaBuilder.prototype.visitClassNode = function(node) {
@@ skipping 116 matching lines @@
 }
 SsaBuilder.prototype.unquote = function(literal) {
   var str = ('' + literal.get$value());
   this.compiler.ensure(str[0] == '@');
   var quotes = 1;
   var quote = str[1];
   while (str[quotes + 1] === quote) quotes++;
   return new StringWrapper(str.substring(quotes + 1, str.length - quotes));
 }
 SsaBuilder.prototype.visitLogicalAndOr = function(node, op) {
-  var isAnd = $assert_bool(($eq(const$280/*const SourceString("&&")*/, op.get$source())));
+  var isAnd = $assert_bool(($eq(const$276/*const SourceString("&&")*/, op.get$source())));
   this.visit(node.receiver);
   var boolifiedLeft = this.popBoolified();
   var condition;
   if ($notnull_bool(isAnd)) {
     condition = boolifiedLeft;
   }
   else {
     condition = new HNot(boolifiedLeft);
     this.add(condition);
   }
@@ skipping 21 matching lines @@
   this.push(not);
 }
 SsaBuilder.prototype.visitUnary = function(node, op, element) {
   this.compiler.unimplemented("visitUnary");
 }
 SsaBuilder.prototype.visitBinary = function(node, op, element) {
   this.visit(node.receiver);
   this.visit(node.argumentsNode);
   var right = this.pop();
   var left = this.pop();
-  if ($notnull_bool($eq(const$283/*const SourceString("+")*/, op.get$source()))) {
+  if ($notnull_bool($eq(const$279/*const SourceString("+")*/, op.get$source()))) {
     this.push(new HAdd(element, [left, right]));
   }
-  else if ($notnull_bool($eq(const$284/*const SourceString("-")*/, op.get$source()))) {
+  else if ($notnull_bool($eq(const$280/*const SourceString("-")*/, op.get$source()))) {
     this.push(new HSubtract(element, [left, right]));
   }
-  else if ($notnull_bool($eq(const$285/*const SourceString("*")*/, op.get$source()))) {
+  else if ($notnull_bool($eq(const$281/*const SourceString("*")*/, op.get$source()))) {
     this.push(new HMultiply(element, [left, right]));
   }
-  else if ($notnull_bool($eq(const$286/*const SourceString("/")*/, op.get$source()))) {
+  else if ($notnull_bool($eq(const$282/*const SourceString("/")*/, op.get$source()))) {
     this.push(new HDivide(element, [left, right]));
   }
-  else if ($notnull_bool($eq(const$287/*const SourceString("~/")*/, op.get$source()))) {
+  else if ($notnull_bool($eq(const$283/*const SourceString("~/")*/, op.get$source()))) {
     this.push(new HTruncatingDivide(element, [left, right]));
   }
-  else if ($notnull_bool($eq(const$288/*const SourceString("%")*/, op.get$source()))) {
+  else if ($notnull_bool($eq(const$284/*const SourceString("%")*/, op.get$source()))) {
     this.push(new HModulo(element, [left, right]));
   }
-  else if ($notnull_bool($eq(const$289/*const SourceString("==")*/, op.get$source()))) {
+  else if ($notnull_bool($eq(const$285/*const SourceString("==")*/, op.get$source()))) {
     this.push(new HEquals(element, [left, right]));
   }
-  else if ($notnull_bool($eq(const$290/*const SourceString("<")*/, op.get$source()))) {
+  else if ($notnull_bool($eq(const$286/*const SourceString("<")*/, op.get$source()))) {
     this.push(new HLess(element, [left, right]));
   }
-  else if ($notnull_bool($eq(const$291/*const SourceString("<=")*/, op.get$source()))) {
+  else if ($notnull_bool($eq(const$287/*const SourceString("<=")*/, op.get$source()))) {
     this.push(new HLessEqual(element, [left, right]));
   }
-  else if ($notnull_bool($eq(const$292/*const SourceString(">")*/, op.get$source()))) {
+  else if ($notnull_bool($eq(const$288/*const SourceString(">")*/, op.get$source()))) {
     this.push(new HGreater(element, [left, right]));
   }
-  else if ($notnull_bool($eq(const$293/*const SourceString(">=")*/, op.get$source()))) {
+  else if ($notnull_bool($eq(const$289/*const SourceString(">=")*/, op.get$source()))) {
     this.push(new HGreaterEqual(element, [left, right]));
   }
 }
 SsaBuilder.prototype.visitSend = function(node) {
   var $0;
   var element = (($0 = this.elements.$index(node)) && $0.is$Element());
   if ((node.selector instanceof Operator)) {
     var op = (($0 = node.selector) && $0.is$Operator());
-    if ($notnull_bool($eq(const$280/*const SourceString("&&")*/, op.get$source())) || $notnull_bool($eq(const$281/*const SourceString("||")*/, op.get$source()))) {
+    if ($notnull_bool($eq(const$276/*const SourceString("&&")*/, op.get$source())) || $notnull_bool($eq(const$277/*const SourceString("||")*/, op.get$source()))) {
       this.visitLogicalAndOr(node, op);
     }
-    else if ($notnull_bool($eq(const$282/*const SourceString("!")*/, op.get$source()))) {
+    else if ($notnull_bool($eq(const$278/*const SourceString("!")*/, op.get$source()))) {
       this.visitLogicalNot(node);
     }
     else if (node.argumentsNode === const$217/*const Prefix()*/ || node.argumentsNode === const$219/*const Postfix()*/) {
       this.visitUnary(node, op, element);
     }
     else {
       this.visitBinary(node, op, element);
     }
   }
   else if ($notnull_bool(node.get$isPropertyAccess())) {
     if (node.receiver != null) {
       this.compiler.unimplemented("SsaBuilder.visitSend with receiver");
     }
     this.stack.add(this.definitions.$index(element));
   }
   else {
     var link = node.get$arguments();
     if (element.kind === const$211/*ElementKind.FOREIGN*/) {
-      link = (($0 = link.get$tail()) && $0.is$Link$Node());
+      link = (($0 = link.get$tail()) && $0.is$Link_Node());
     }
     var arguments = [];
-    for (; !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+    for (; !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
       this.visit((($0 = link.get$head()) && $0.is$Node()));
       arguments.add$1(this.pop());
     }
     if (element.kind === const$211/*ElementKind.FOREIGN*/) {
       var literal = (($0 = node.get$arguments().get$head()) && $0.is$LiteralString());
       this.compiler.ensure((literal instanceof LiteralString));
       this.push(new HInvokeForeign(element, arguments, this.unquote(literal)));
     }
     else {
       var selector = (($0 = node.selector) && $0.is$Identifier());
@@ skipping 15 matching lines @@
 }
 SsaBuilder.prototype.visitLiteralString = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitLiteralNull = function(node) {
   this.push(new HLiteral(null));
 }
 SsaBuilder.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.get$nodes();
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 SsaBuilder.prototype.visitOperator = function(node) {
   unreachable();
 }
 SsaBuilder.prototype.visitReturn = function(node) {
   var value;
   if (node.expression == null) {
     value = new HLiteral(null);
@@ skipping 24 matching lines @@
   $assert(!$notnull_bool(link.isEmpty()) && $notnull_bool(link.get$tail().isEmpty$0()), "!link.isEmpty() && link.tail.isEmpty()", "builder.dart", 520, 12);
   this.visit((($0 = link.get$head()) && $0.is$Node()));
   var value = this.pop();
   var element = (($0 = this.elements.$index(node)) && $0.is$VariableElement());
   this.definitions.$setindex(element, this.guard(element.type, value));
   return value;
 }
 SsaBuilder.prototype.visitVariableDefinitions = function(node) {
   var $0;
   for (var link = node.definitions.get$nodes();
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     var definition = (($0 = link.get$head()) && $0.is$Node());
     if ((definition instanceof Identifier)) {
       var initialValue = new HLiteral(null);
       this.add(initialValue);
       this.definitions.$setindex(this.elements.$index(definition), initialValue);
     }
     else {
       $assert((definition instanceof SendSet), "definition is SendSet", "builder.dart", 538, 16);
       this.updateDefinition((definition && definition.is$SendSet()));
     }
@@ skipping 13 matching lines @@
 $inherits(SsaCodeGeneratorTask, CompilerTask);
 SsaCodeGeneratorTask.prototype.get$name = function() {
   return 'SSA code generator';
 }
 SsaCodeGeneratorTask.prototype.generate = function(function_, graph) {
   var $this = this; // closure support
   return $assert_String(this.measure((function () {
     var $0;
     var parameterNames = new LinkedHashMapImplementation();
     for (var link = function_.parameters;
-     !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Element())) {
+     !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Element())) {
       var element = (($0 = link.get$head()) && $0.is$Element());
       parameterNames.$setindex(element, JsNames.getValid(('' + element.name)));
     }
     if (false/*null.GENERATE_SSA_TRACE*/) {
       HTracer.HTracer$singleton$factory().traceGraph("codegen", graph);
     }
     var code = $this.generateMethod(function_.name, parameterNames, graph);
     return code;
   })
   ));
 }
 SsaCodeGeneratorTask.prototype.generateMethod = function(methodName, parameterNames, graph) {
   var $0;
   new SsaPhiEliminator().visitGraph(graph);
   if (false/*null.GENERATE_SSA_TRACE*/) {
     HTracer.HTracer$singleton$factory().traceGraph("no-phi", graph);
   }
   var buffer = new StringBufferImpl("");
   var codegen = new SsaCodeGenerator(this.compiler, buffer, parameterNames);
   codegen.visitGraph(graph);
   var parameters = new StringBufferImpl("");
-  var names = (($0 = parameterNames.getValues()) && $0.is$List$String());
+  var names = (($0 = parameterNames.getValues()) && $0.is$List_String());
   for (var i = 0;
    i < $assert_num(names.length); i++) {
     if (i != 0) parameters.add(', ');
     parameters.add(names.$index(i));
   }
   return ('function ' + methodName + '(' + parameters + ') {\n' + buffer + '}\n');
 }
 // ********** Code for SsaCodeGenerator **************
 function SsaCodeGenerator(compiler, buffer, parameterNames) {
   this.indent = 0
@@ skipping 300 matching lines @@
 SsaCodeGenerator.prototype.visitThrow = function(node) {
   var $0;
   this.buffer.add('throw ');
   this.use((($0 = node.inputs.$index(0)) && $0.is$HInstruction()));
   this.buffer.add(';\n');
 }
 SsaCodeGenerator.prototype.visitTypeGuard = function(node) {
   var $0;
   var name;
   if ($notnull_bool(node.isNumber())) {
-    name = const$310/*const SourceString('guard\$num')*/;
+    name = const$306/*const SourceString('guard\$num')*/;
   }
   else {
     unreachable();
   }
   var element = this.compiler.universe.find(name);
   this.compiler.worklist.add(element);
   this.buffer.add(('' + name + '('));
   this.use((($0 = node.inputs.$index(0)) && $0.is$HInstruction()));
   this.buffer.add(')');
 }
@@ skipping 15 matching lines @@
 }
 SsaCodeGenerator.prototype.visitLocal = function(node) {
   this.buffer.add(('var ' + this.local(node)));
 }
 SsaCodeGenerator.prototype.visit$1 = SsaCodeGenerator.prototype.visit;
 // ********** Code for JsNames **************
 function JsNames() {}
 JsNames.get$reserved = function() {
   if ($globals.JsNames__reserved == null) {
     $globals.JsNames__reserved = new HashSetImplementation();
-    $globals.JsNames__reserved.addAll(const$304/*JsNames.reservedPropertySymbols*/);
-    $globals.JsNames__reserved.addAll(const$306/*JsNames.reservedGlobalSymbols*/);
-    $globals.JsNames__reserved.addAll(const$308/*JsNames.javaScriptKeywords*/);
+    $globals.JsNames__reserved.addAll(const$300/*JsNames.reservedPropertySymbols*/);
+    $globals.JsNames__reserved.addAll(const$302/*JsNames.reservedGlobalSymbols*/);
+    $globals.JsNames__reserved.addAll(const$304/*JsNames.javaScriptKeywords*/);
   }
   return $globals.JsNames__reserved;
 }
 JsNames.getValid = function(name) {
   if (JsNames.get$reserved().contains(name)) {
     name = ('\$' + name);
     $assert(!JsNames.get$reserved().contains(name), "!reserved.contains(name)", "js_names.dart", 171, 14);
   }
   else if (name.contains("$")) {
     name = name.replaceAll("$", "_$");
@@ skipping 1251 matching lines @@
 }
 HRelational.prototype.computeType = function() {
   return $notnull_bool(this.inputs.$index(0).isNumber$0()) ? 1/*HInstruction.TYPE_BOOLEAN*/ : 0/*HInstruction.TYPE_UNKNOWN*/;
 }
 HRelational.prototype.hasOnlyNumberInputs = function() {
   return this.computeInputsType() == 2/*HInstruction.TYPE_NUMBER*/;
 }
 // ********** Code for HEquals **************
 function HEquals(element, inputs) {
   // Initializers done
-  HRelational.call(this, (element && element.is$Element()), (inputs && inputs.is$List$HInstruction()));
+  HRelational.call(this, (element && element.is$Element()), (inputs && inputs.is$List_HInstruction()));
 }
 $inherits(HEquals, HRelational);
 HEquals.prototype.evaluate = function(a, b) {
   return a == b;
 }
 HEquals.prototype.accept = function(visitor) {
   return visitor.visitEquals(this);
 }
 HEquals.prototype.typeEquals = function(other) {
   return (other instanceof HEquals);
 }
 HEquals.prototype.dataEquals = function(other) {
   return true;
 }
 HEquals.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HEquals.prototype.dataEquals$1 = function($0) {
   return this.dataEquals(($0 && $0.is$HInstruction()));
 };
 // ********** Code for HGreater **************
 function HGreater(element, inputs) {
   // Initializers done
-  HRelational.call(this, (element && element.is$Element()), (inputs && inputs.is$List$HInstruction()));
+  HRelational.call(this, (element && element.is$Element()), (inputs && inputs.is$List_HInstruction()));
 }
 $inherits(HGreater, HRelational);
 HGreater.prototype.evaluate = function(a, b) {
   return a > b;
 }
 HGreater.prototype.accept = function(visitor) {
   return visitor.visitGreater(this);
 }
 HGreater.prototype.typeEquals = function(other) {
   return (other instanceof HGreater);
 }
 HGreater.prototype.dataEquals = function(other) {
   return true;
 }
 HGreater.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HGreater.prototype.dataEquals$1 = function($0) {
   return this.dataEquals(($0 && $0.is$HInstruction()));
 };
 // ********** Code for HGreaterEqual **************
 function HGreaterEqual(element, inputs) {
   // Initializers done
-  HRelational.call(this, (element && element.is$Element()), (inputs && inputs.is$List$HInstruction()));
+  HRelational.call(this, (element && element.is$Element()), (inputs && inputs.is$List_HInstruction()));
 }
 $inherits(HGreaterEqual, HRelational);
 HGreaterEqual.prototype.evaluate = function(a, b) {
   return a >= b;
 }
 HGreaterEqual.prototype.accept = function(visitor) {
   return visitor.visitGreaterEqual(this);
 }
 HGreaterEqual.prototype.typeEquals = function(other) {
   return (other instanceof HGreaterEqual);
 }
 HGreaterEqual.prototype.dataEquals = function(other) {
   return true;
 }
 HGreaterEqual.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HGreaterEqual.prototype.dataEquals$1 = function($0) {
   return this.dataEquals(($0 && $0.is$HInstruction()));
 };
 // ********** Code for HLess **************
 function HLess(element, inputs) {
   // Initializers done
-  HRelational.call(this, (element && element.is$Element()), (inputs && inputs.is$List$HInstruction()));
+  HRelational.call(this, (element && element.is$Element()), (inputs && inputs.is$List_HInstruction()));
 }
 $inherits(HLess, HRelational);
 HLess.prototype.evaluate = function(a, b) {
   return a < b;
 }
 HLess.prototype.accept = function(visitor) {
   return visitor.visitLess(this);
 }
 HLess.prototype.typeEquals = function(other) {
   return (other instanceof HLess);
 }
 HLess.prototype.dataEquals = function(other) {
   return true;
 }
 HLess.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 HLess.prototype.dataEquals$1 = function($0) {
   return this.dataEquals(($0 && $0.is$HInstruction()));
 };
 // ********** Code for HLessEqual **************
 function HLessEqual(element, inputs) {
   // Initializers done
-  HRelational.call(this, (element && element.is$Element()), (inputs && inputs.is$List$HInstruction()));
+  HRelational.call(this, (element && element.is$Element()), (inputs && inputs.is$List_HInstruction()));
 }
 $inherits(HLessEqual, HRelational);
 HLessEqual.prototype.evaluate = function(a, b) {
   return a <= b;
 }
 HLessEqual.prototype.accept = function(visitor) {
   return visitor.visitLessEqual(this);
 }
 HLessEqual.prototype.typeEquals = function(other) {
   return (other instanceof HLessEqual);
@@ skipping 1093 matching lines @@
     }
     if (!$notnull_bool(f.call$2(current, count))) return false;
   }
   return true;
 }
 HValidator.prototype.visitInstruction = function(instruction) {
   var $this = this; // closure support
   function hasCorrectInputs(instruction) {
     var $0;
     var inBasicBlock = $assert_bool(instruction.isInBasicBlock$0());
-    return HValidator.everyInstruction((($0 = instruction.get$inputs()) && $0.is$List$HInstruction()), (function (input, count) {
+    return HValidator.everyInstruction((($0 = instruction.get$inputs()) && $0.is$List_HInstruction()), (function (input, count) {
       var $0;
       if ($notnull_bool(inBasicBlock)) {
-        return HValidator.countInstruction((($0 = input.get$usedBy()) && $0.is$List$HInstruction()), (instruction && instruction.is$HInstruction())) == count;
+        return HValidator.countInstruction((($0 = input.get$usedBy()) && $0.is$List_HInstruction()), (instruction && instruction.is$HInstruction())) == count;
       }
       else {
-        return HValidator.countInstruction((($0 = input.get$usedBy()) && $0.is$List$HInstruction()), (instruction && instruction.is$HInstruction())) == 0;
+        return HValidator.countInstruction((($0 = input.get$usedBy()) && $0.is$List_HInstruction()), (instruction && instruction.is$HInstruction())) == 0;
       }
     })
     );
   }
   function hasCorrectUses(instruction) {
     var $0;
     if (!$notnull_bool(instruction.isInBasicBlock$0())) return true;
-    return HValidator.everyInstruction((($0 = instruction.get$usedBy()) && $0.is$List$HInstruction()), (function (use, count) {
+    return HValidator.everyInstruction((($0 = instruction.get$usedBy()) && $0.is$List_HInstruction()), (function (use, count) {
       var $0;
-      return HValidator.countInstruction((($0 = use.get$inputs()) && $0.is$List$HInstruction()), (instruction && instruction.is$HInstruction())) == count;
+      return HValidator.countInstruction((($0 = use.get$inputs()) && $0.is$List_HInstruction()), (instruction && instruction.is$HInstruction())) == count;
     })
     );
   }
   if (instruction.block !== this.currentBlock) {
     this.markInvalid("Instruction in wrong block");
   }
   if (!$notnull_bool(hasCorrectInputs(instruction))) {
     this.markInvalid("Incorrect inputs");
   }
   if (!$notnull_bool(hasCorrectUses(instruction))) {
@@ skipping 171 matching lines @@
   var $0;
   this.resolver.resolveType((($0 = this.parser.parse(element)) && $0.is$ClassNode()));
 }
 Compiler.prototype.resolveSignature = function(element) {
   var $0;
   this.resolver.resolveSignature((($0 = this.parser.parse(element)) && $0.is$FunctionExpression()));
 }
 Compiler.prototype.getGeneratedCode = function() {
   var $0;
   var buffer = new StringBufferImpl("");
-  var codeBlocks = (($0 = this.universe.generatedCode.getValues()) && $0.is$List$String());
+  var codeBlocks = (($0 = this.universe.generatedCode.getValues()) && $0.is$List_String());
   for (var i = codeBlocks.length - 1;
    i >= 0; i--) {
     buffer.add(codeBlocks.$index(i));
   }
   buffer.add('main();\n');
   return buffer.toString();
 }
 Compiler.prototype.reportWarning = function(node, message) {
 
 }
@@ skipping 47 matching lines @@
   return (($0 = this.measure((function () {
     var visitor = new SignatureResolverVisitor($this.compiler);
     visitor.visit(tree);
     visitor = new FullResolverVisitor.from$ctor(visitor);
     visitor.visit(tree.body);
     while (!$this.toResolve.isEmpty()) {
       $this.toResolve.removeFirst().resolve$1($this.compiler);
     }
     return visitor.mapping;
   })
-  )) && $0.is$Map$Node$Element());
+  )) && $0.is$Map_Node$Element());
 }
 ResolverTask.prototype.resolveType = function(tree) {
   var $this = this; // closure support
   this.measure((function () {
     var visitor = new ClassResolverVisitor($this.compiler);
     visitor.visit(tree);
   })
   );
 }
 ResolverTask.prototype.resolveSignature = function(node) {
@@ skipping 16 matching lines @@
 }
 ResolverVisitor.from$ctor = function(other) {
   this.compiler = other.compiler;
   this.mapping = other.mapping;
   this.context = other.context;
   // Initializers done
 }
 ResolverVisitor.from$ctor.prototype = ResolverVisitor.prototype;
 ResolverVisitor.prototype.is$Visitor = function(){return this;};
 ResolverVisitor.prototype.error = function(node, kind, arguments) {
-  var error = new ResolutionError(kind, (arguments && arguments.is$List$Type()));
+  var error = new ResolutionError(kind, (arguments && arguments.is$List_Type()));
   this.compiler.cancel(error.toString());
 }
 ResolverVisitor.prototype.warning = function(node, kind, arguments) {
-  var warning = new ResolutionWarning(kind, (arguments && arguments.is$List$Type()));
+  var warning = new ResolutionWarning(kind, (arguments && arguments.is$List_Type()));
   this.compiler.reportWarning(node, warning.toString());
 }
 ResolverVisitor.prototype.cancel = function(node, message) {
   this.compiler.cancel(message);
 }
 ResolverVisitor.prototype.visit = function(node) {
   if (node == null) return null;
   return node.accept(this);
 }
 ResolverVisitor.prototype.visitIdentifier = function(node) {
@@ skipping 39 matching lines @@
   ResolverVisitor.call(this, compiler);
 }
 $inherits(SignatureResolverVisitor, ResolverVisitor);
 SignatureResolverVisitor.prototype.visitFunctionExpression = function(node) {
   var $0;
   var enclosingElement = (($0 = this.visit(node.name)) && $0.is$FunctionElement());
   this.context = new Scope.enclosing$ctor(this.context, enclosingElement);
   if (enclosingElement.parameters == null) {
     var visitor = new ParametersVisitor(this);
     visitor.visit(node.parameters);
-    enclosingElement.parameters = (($0 = visitor.elements.toLink()) && $0.is$Link$Element());
+    enclosingElement.parameters = (($0 = visitor.elements.toLink()) && $0.is$Link_Element());
   }
   else {
     var parameterNodes = node.parameters.get$nodes();
     for (var link = enclosingElement.parameters;
-     !$notnull_bool(link.isEmpty()) && !$notnull_bool(parameterNodes.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Element()), parameterNodes = (($0 = parameterNodes.get$tail()) && $0.is$Link$Node())) {
+     !$notnull_bool(link.isEmpty()) && !$notnull_bool(parameterNodes.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Element()), parameterNodes = (($0 = parameterNodes.get$tail()) && $0.is$Link_Node())) {
       this.defineElement((($0 = parameterNodes.get$head().get$definitions().get$nodes().get$head()) && $0.is$Node()), (($0 = link.get$head()) && $0.is$Element()));
     }
   }
   return enclosingElement;
 }
 // ********** Code for FullResolverVisitor **************
 function FullResolverVisitor() {}
 FullResolverVisitor.from$ctor = function(other) {
   // Initializers done
   ResolverVisitor.from$ctor.call(this, other);
@@ skipping 23 matching lines @@
   this.visitIn(node.update, scope);
   this.visitIn(node.body, scope);
 }
 FullResolverVisitor.prototype.visitFunctionExpression = function(node) {
   var $0;
   this.visit(node.returnType);
   var enclosingElement = (($0 = this.visit(node.name)) && $0.is$FunctionElement());
   this.context = new Scope.enclosing$ctor(this.context, enclosingElement);
   var visitor = new ParametersVisitor(this);
   visitor.visit(node.parameters);
-  enclosingElement.parameters = (($0 = visitor.elements.toLink()) && $0.is$Link$Element());
+  enclosingElement.parameters = (($0 = visitor.elements.toLink()) && $0.is$Link_Element());
   this.visit(node.body);
   this.context = this.context.parent;
   return enclosingElement;
 }
 FullResolverVisitor.prototype.visitIf = function(node) {
   this.visit(node.condition);
   this.visit(node.thenPart);
   this.visit(node.elsePart);
 }
 FullResolverVisitor.prototype.potentiallyMapOperatorToMethodName = function(name) {
@@ skipping 50 matching lines @@
 }
 FullResolverVisitor.prototype.visitLiteralString = function(node) {
 
 }
 FullResolverVisitor.prototype.visitLiteralNull = function(node) {
 
 }
 FullResolverVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.get$nodes();
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 FullResolverVisitor.prototype.visitOperator = function(node) {
   this.cancel(node, "Unimplemented");
 }
 FullResolverVisitor.prototype.visitReturn = function(node) {
   this.visit(node.expression);
 }
 FullResolverVisitor.prototype.visitThrow = function(node) {
   this.visit(node.expression);
 }
 FullResolverVisitor.prototype.visitVariableDefinitions = function(node) {
   this.visit(node.type);
   var visitor = new VariableDefinitionsVisitor(node, this, const$258/*ElementKind.VARIABLE*/);
   visitor.visit(node.definitions);
 }
 // ********** Code for ClassResolverVisitor **************
 function ClassResolverVisitor(compiler) {
   this.compiler = compiler;
   this.context = new TopScope(compiler.universe);
   // Initializers done
-  AbstractVisitor$Type.call(this);
+  AbstractVisitor_Type.call(this);
 }
-$inherits(ClassResolverVisitor, AbstractVisitor$Type);
+$inherits(ClassResolverVisitor, AbstractVisitor_Type);
 ClassResolverVisitor.prototype.visitClassNode = function(node) {
   var $0;
   var element = (($0 = this.context.lookup(node.name.get$source())) && $0.is$ClassElement());
   this.compiler.ensure(element != null);
   this.compiler.ensure(!$notnull_bool(element.isResolved));
   element.supertype = this.visit(node.superclass);
   for (var link = node.interfaces.get$nodes();
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-    element.interfaces = (($0 = element.interfaces.prepend(this.visit((($0 = link.get$head()) && $0.is$Node())))) && $0.is$Link$Type());
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
+    element.interfaces = (($0 = element.interfaces.prepend(this.visit((($0 = link.get$head()) && $0.is$Node())))) && $0.is$Link_Type());
   }
   return element.computeType(this.compiler, null);
 }
 ClassResolverVisitor.prototype.visitTypeAnnotation = function(node) {
   var $0;
   var name = node.typeName;
   var element = this.context.lookup(name.get$source());
   if (element == null) {
     this.compiler.cancel(new ResolutionError(const$224/*MessageKind.CANNOT_RESOLVE_TYPE*/, [name]).toString());
   }
@@ skipping 16 matching lines @@
 }
 ClassResolverVisitor.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$Node()));
 };
 // ********** Code for VariableDefinitionsVisitor **************
 function VariableDefinitionsVisitor(definitions, resolver, kind) {
   this.definitions = definitions;
   this.resolver = resolver;
   this.kind = kind;
   // Initializers done
-  AbstractVisitor$SourceString.call(this);
+  AbstractVisitor_SourceString.call(this);
 }
-$inherits(VariableDefinitionsVisitor, AbstractVisitor$SourceString);
+$inherits(VariableDefinitionsVisitor, AbstractVisitor_SourceString);
 VariableDefinitionsVisitor.prototype.get$definitions = function() { return this.definitions; };
 VariableDefinitionsVisitor.prototype.set$definitions = function(value) { return this.definitions = value; };
 VariableDefinitionsVisitor.prototype.get$kind = function() { return this.kind; };
 VariableDefinitionsVisitor.prototype.set$kind = function(value) { return this.kind = value; };
 VariableDefinitionsVisitor.prototype.visitSendSet = function(node) {
   var $0;
   $assert(node.get$arguments().get$tail().isEmpty$0(), "node.arguments.tail.isEmpty()", "resolver.dart", 355, 12);
   if (node.receiver != null) {
     this.resolver.cancel(node, "receiver on a variable definition not implemented");
   }
   var selector = (($0 = node.selector) && $0.is$Identifier());
   this.resolver.visit((($0 = node.get$arguments().get$head()) && $0.is$Node()));
   return (($0 = this.visit(node.selector)) && $0.is$SourceString());
 }
 VariableDefinitionsVisitor.prototype.visitIdentifier = function(node) {
   return node.get$source();
 }
 VariableDefinitionsVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.get$nodes();
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     var name = (($0 = this.visit((($0 = link.get$head()) && $0.is$Node()))) && $0.is$SourceString());
     var element = new VariableElement((($0 = link.get$head()) && $0.is$Node()), this.definitions.type, this.kind, name, this.resolver.context.enclosingElement);
     var existing = this.resolver.defineElement((($0 = link.get$head()) && $0.is$Node()), element);
     if ($ne(existing, element)) {
       this.resolver.error(node, const$230/*MessageKind.DUPLICATE_DEFINITION*/, [link.get$head()]);
     }
   }
 }
 VariableDefinitionsVisitor.prototype.visit = function(node) {
   return node.accept(this);
 }
 VariableDefinitionsVisitor.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$Node()));
 };
 // ********** Code for ParametersVisitor **************
 function ParametersVisitor(resolver) {
   this.resolver = resolver;
   this.elements = new LinkBuilderImplementation();
   // Initializers done
-  AbstractVisitor$Element.call(this);
+  AbstractVisitor_Element.call(this);
 }
-$inherits(ParametersVisitor, AbstractVisitor$Element);
+$inherits(ParametersVisitor, AbstractVisitor_Element);
 ParametersVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.get$nodes();
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     this.elements.addLast(this.visit((($0 = link.get$head()) && $0.is$Node())));
   }
 }
 ParametersVisitor.prototype.visitVariableDefinitions = function(node) {
   this.resolver.visit(node.type);
   var visitor = new VariableDefinitionsVisitor(node, this.resolver, const$228/*ElementKind.PARAMETER*/);
   visitor.visit(node.definitions);
   return this.resolver.mapping.$index(node.definitions.get$nodes().get$head());
 }
 ParametersVisitor.prototype.visit = function(node) {
@@ skipping 15 matching lines @@
 }
 Scope.top$ctor.prototype = Scope.prototype;
 Scope.enclosing$ctor = function(parent, enclosingElement) {
   this.parent = parent;
   this.enclosingElement = enclosingElement;
   this.elements = $map([]);
   // Initializers done
 }
 Scope.enclosing$ctor.prototype = Scope.prototype;
 Scope.prototype.get$parent = function() { return this.parent; };
+Scope.prototype.get$enclosingElement = function() { return this.enclosingElement; };
 Scope.prototype.lookup = function(name) {
   var $0;
   var element = (($0 = this.elements.$index(name)) && $0.is$Element());
   if (element != null) return element;
   return this.parent.lookup(name);
 }
 Scope.prototype.add = function(element) {
   var $0;
   if (this.elements.containsKey(element.name)) return (($0 = this.elements.$index(element.name)) && $0.is$Element());
   this.elements.$setindex(element.name, element);
@@ skipping 152 matching lines @@
     message = ('' + message + ': ' + reason);
   }
   $throw(new CancelTypeCheckException(node, message));
 }
 TypeCheckerVisitor.prototype.reportTypeWarning = function(node, kind, arguments) {
   this.compiler.reportWarning(node, new TypeWarning(kind, arguments).toString());
 }
 TypeCheckerVisitor.prototype.nonVoidType = function(node) {
   var type = this.type(node);
   if ($eq(type, this.types.voidType)) {
-    this.reportTypeWarning(node, const$273/*MessageKind.VOID_EXPRESSION*/, const$15/*const []*/);
+    this.reportTypeWarning(node, const$269/*MessageKind.VOID_EXPRESSION*/, const$15/*const []*/);
   }
   return type;
 }
 TypeCheckerVisitor.prototype.typeWithDefault = function(node, defaultValue) {
   return node != null ? this.type(node) : defaultValue;
 }
 TypeCheckerVisitor.prototype.type = function(node) {
   var $0;
   if (node == null) this.fail(null, 'unexpected node: null');
   var result = (($0 = node.accept(this)) && $0.is$Type());
   return result;
 }
 TypeCheckerVisitor.prototype.get$type = function() {
   return TypeCheckerVisitor.prototype.type.bind(this);
 }
 TypeCheckerVisitor.prototype.checkAssignable = function(node, s, t) {
   if (!$notnull_bool(this.types.isAssignable(s, t))) {
-    this.reportTypeWarning(node, const$266/*MessageKind.NOT_ASSIGNABLE*/, [s, t]);
+    this.reportTypeWarning(node, const$262/*MessageKind.NOT_ASSIGNABLE*/, [s, t]);
   }
 }
 TypeCheckerVisitor.prototype.visitBlock = function(node) {
   this.type(node.statements);
   return this.types.voidType;
 }
 TypeCheckerVisitor.prototype.visitClassNode = function(node) {
   this.fail(node);
 }
 TypeCheckerVisitor.prototype.visitExpressionStatement = function(node) {
@@ skipping 20 matching lines @@
   this.type(node.thenPart);
   if ($notnull_bool(node.get$hasElsePart())) this.type(node.elsePart);
   return this.types.voidType;
 }
 TypeCheckerVisitor.prototype.visitSend = function(node) {
   var $0;
   var target = this.elements.$index(node);
   var selector = (($0 = node.selector) && $0.is$Identifier());
   if (target != null) {
     var name = selector.get$source();
-    if ($notnull_bool($eq(name, const$233/*const SourceString('+')*/)) || $notnull_bool($eq(name, const$270/*const SourceString('=')*/)) || $notnull_bool($eq(name, const$235/*const SourceString('-')*/)) || $notnull_bool($eq(name, const$237/*const SourceString('*')*/)) || $notnull_bool($eq(name, const$239/*const SourceString('/')*/)) || $notnull_bool($eq(name, const$247/*const SourceString('<')*/)) || $notnull_bool($eq(name, const$241/*const SourceString('~/')*/))) {
+    if ($notnull_bool($eq(name, const$233/*const SourceString('+')*/)) || $notnull_bool($eq(name, const$266/*const SourceString('=')*/)) || $notnull_bool($eq(name, const$235/*const SourceString('-')*/)) || $notnull_bool($eq(name, const$237/*const SourceString('*')*/)) || $notnull_bool($eq(name, const$239/*const SourceString('/')*/)) || $notnull_bool($eq(name, const$247/*const SourceString('<')*/)) || $notnull_bool($eq(name, const$241/*const SourceString('~/')*/))) {
       return this.types.dynamicType;
     }
     var targetType = target.computeType$2(this.compiler, this.types);
     if ($notnull_bool(node.get$isPropertyAccess())) {
       return (targetType && targetType.is$Type());
     }
     else if ($notnull_bool(node.get$isFunctionObjectInvocation())) {
       this.fail(node);
     }
     else {
       if (!(targetType instanceof FunctionType)) {
         if ((target instanceof ForeignElement)) {
           return this.types.dynamicType;
         }
         this.fail(node, 'can only handle function types');
       }
       var funType = (targetType && targetType.is$FunctionType());
       var formals = funType.parameterTypes;
       var arguments = node.get$arguments();
       while ((!$notnull_bool(formals.isEmpty())) && (!$notnull_bool(arguments.isEmpty()))) {
         var argument = (($0 = arguments.get$head()) && $0.is$Node());
         var argumentType = this.type(argument);
         this.checkAssignable(argument, argumentType, (($0 = formals.get$head()) && $0.is$Type()));
-        formals = (($0 = formals.get$tail()) && $0.is$Link$Type());
-        arguments = (($0 = arguments.get$tail()) && $0.is$Link$Node());
+        formals = (($0 = formals.get$tail()) && $0.is$Link_Type());
+        arguments = (($0 = arguments.get$tail()) && $0.is$Link_Node());
       }
       if (!$notnull_bool(formals.isEmpty())) {
         this.compiler.reportWarning(node, 'missing argument');
       }
       if (!$notnull_bool(arguments.isEmpty())) {
         this.compiler.reportWarning((($0 = arguments.get$head()) && $0.is$Node()), 'additional arguments');
       }
       return funType.returnType;
     }
   }
@@ skipping 20 matching lines @@
 }
 TypeCheckerVisitor.prototype.visitLiteralString = function(node) {
   return this.types.stringType;
 }
 TypeCheckerVisitor.prototype.visitLiteralNull = function(node) {
   return this.types.dynamicType;
 }
 TypeCheckerVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.get$nodes();
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     this.type((($0 = link.get$head()) && $0.is$Node()));
   }
   return null;
 }
 TypeCheckerVisitor.prototype.visitOperator = function(node) {
   return this.types.dynamicType;
 }
 TypeCheckerVisitor.prototype.visitReturn = function(node) {
   var expression = node.expression;
   var isVoidFunction = (this.expectedReturnType === this.types.voidType);
   if (expression != null) {
     var expressionType = this.type(expression);
     if (isVoidFunction && !$notnull_bool(this.types.isAssignable(expressionType, this.types.voidType))) {
-      this.reportTypeWarning(expression, const$264/*MessageKind.RETURN_VALUE_IN_VOID*/, const$15/*const []*/);
+      this.reportTypeWarning(expression, const$260/*MessageKind.RETURN_VALUE_IN_VOID*/, const$15/*const []*/);
     }
     else {
       this.checkAssignable(expression, expressionType, this.expectedReturnType);
     }
   }
   else if (!$notnull_bool(this.types.isAssignable(this.expectedReturnType, this.types.voidType))) {
-    this.reportTypeWarning(node, const$268/*MessageKind.RETURN_NOTHING*/, [this.expectedReturnType]);
+    this.reportTypeWarning(node, const$264/*MessageKind.RETURN_NOTHING*/, [this.expectedReturnType]);
   }
   return null;
 }
 TypeCheckerVisitor.prototype.visitThrow = function(node) {
   if (node.expression != null) this.type(node.expression);
   return this.types.voidType;
 }
 TypeCheckerVisitor.prototype.visitTypeAnnotation = function(node) {
   if (node.typeName == null) return this.types.dynamicType;
   var name = node.typeName.get$source();
   var type = this.types.lookup(name);
   if (type == null) this.fail(node, ('unsupported type ' + name));
   return type;
 }
 TypeCheckerVisitor.prototype.visitVariableDefinitions = function(node) {
   var $0;
   var type = this.typeWithDefault(node.type, this.types.dynamicType);
   if ($eq(type, this.types.voidType)) {
-    this.reportTypeWarning(node.type, const$271/*MessageKind.VOID_VARIABLE*/, const$15/*const []*/);
+    this.reportTypeWarning(node.type, const$267/*MessageKind.VOID_VARIABLE*/, const$15/*const []*/);
     type = this.types.dynamicType;
   }
   for (var link = node.definitions.get$nodes();
-   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     var initialization = (($0 = link.get$head()) && $0.is$Node());
     this.compiler.ensure((initialization instanceof Identifier) || (initialization instanceof Send));
     if ((initialization instanceof Send)) {
       var initializer = this.nonVoidType((($0 = link.get$head()) && $0.is$Node()));
       this.checkAssignable(node, type, initializer);
     }
   }
   return null;
 }
 // ********** Code for Universe **************
@@ skipping 63 matching lines @@
 function ResolutionWarning(kind, arguments) {
   this.message = new Message(kind, arguments);
   // Initializers done
 }
 ResolutionWarning.prototype.toString = function() {
   return this.message.toString();
 }
 ResolutionWarning.prototype.toString$0 = ResolutionWarning.prototype.toString;
 // ********** Code for top level **************
 function unreachable() {
-  $throw(const$275/*const Exception("Internal Error (Leg): UNREACHABLE")*/);
+  $throw(const$271/*const Exception("Internal Error (Leg): UNREACHABLE")*/);
 }
 //  ********** Library frog_leg **************
 // ********** Code for WorldCompiler **************
 function WorldCompiler(world, script) {
   this.world = world;
   // Initializers done
   Compiler.call(this, script);
 }
 $inherits(WorldCompiler, Compiler);
 WorldCompiler.prototype.log = function(message) {
@@ skipping 245 matching lines @@
   }
   var $list = orderValuesByKeys(this._usedOperators);
   for (var $i = 0;$i < $list.length; $i++) {
     var opImpl = $list.$index($i);
     w.writeln($assert_String(opImpl));
   }
 }
 CoreJs.prototype.generate$1 = function($0) {
   return this.generate(($0 && $0.is$CodeWriter()));
 };
+// ********** Code for lang_Element **************
+function lang_Element(name, _enclosingElement) {
+  this.name = name;
+  this._enclosingElement = _enclosingElement;
+  // Initializers done
+  this._jsname = this.name;
+}
+lang_Element.prototype.is$lang_Element = function(){return this;};
+lang_Element.prototype.get$name = function() { return this.name; };
+lang_Element.prototype.set$name = function(value) { return this.name = value; };
+lang_Element.prototype.get$library = function() {
+  return null;
+}
+lang_Element.prototype.get$span = function() {
+  return null;
+}
+lang_Element.prototype.get$isNative = function() {
+  return false;
+}
+lang_Element.prototype.hashCode = function() {
+  return this.name.hashCode();
+}
+lang_Element.prototype.get$jsname = function() {
+  return this._jsname;
+}
+lang_Element.prototype.resolve = function() {
+
+}
+lang_Element.prototype.get$typeParameters = function() {
+  return null;
+}
+lang_Element.prototype.get$enclosingElement = function() {
+  var $0;
+  return (($0 = this._enclosingElement == null ? this.get$library() : this._enclosingElement) && $0.is$lang_Element());
+}
+lang_Element.prototype.set$enclosingElement = function(e) {
+  return this._enclosingElement = e;
+}
+lang_Element.prototype.resolveType = function(node, typeErrors) {
+  var $0;
+  if (node == null) return $globals.world.varType;
+  if (node.type != null) return node.type;
+  if ((node instanceof NameTypeReference)) {
+    var typeRef = (node && node.is$NameTypeReference());
+    var name;
+    if (typeRef.names != null) {
+      name = $assert_String(typeRef.names.last().get$name());
+    }
+    else {
+      name = typeRef.name.name;
+    }
+    if (this.get$typeParameters() != null) {
+      var $list = this.get$typeParameters();
+      for (var $i = 0;$i < $list.length; $i++) {
+        var tp = $list.$index($i);
+        if ($notnull_bool($eq(tp.get$name(), name))) {
+          typeRef.type = (tp && tp.is$lang_Type());
+        }
+      }
+    }
+    if (typeRef.type != null) {
+      return typeRef.type;
+    }
+    return this.get$enclosingElement().resolveType(node, typeErrors);
+  }
+  else if ((node instanceof GenericTypeReference)) {
+    var typeRef = (node && node.is$GenericTypeReference());
+    var baseType = this.resolveType(typeRef.baseType, typeErrors);
+    if (!$notnull_bool(baseType.get$isGeneric())) {
+      $globals.world.error(('' + baseType.get$name() + ' is not generic'), typeRef.span);
+      return null;
+    }
+    if (typeRef.typeArguments.length != baseType.get$typeParameters().length) {
+      $globals.world.error('wrong number of type arguments', typeRef.span);
+      return null;
+    }
+    var typeArgs = [];
+    for (var i = 0;
+     i < typeRef.typeArguments.length; i++) {
+      var extendsType = baseType.get$typeParameters().$index(i).get$extendsType();
+      var typeArg = this.resolveType((($0 = typeRef.typeArguments.$index(i)) && $0.is$TypeReference()), typeErrors);
+      typeArgs.add$1(typeArg);
+      if ($notnull_bool($ne(extendsType, null)) && !(typeArg instanceof ParameterType)) {
+        typeArg.ensureSubtypeOf$3(extendsType, typeRef.typeArguments.$index(i).get$span(), typeErrors);
+      }
+    }
+    typeRef.type = (($0 = baseType.getOrMakeConcreteType$1(typeArgs)) && $0.is$lang_Type());
+  }
+  else if ((node instanceof FunctionTypeReference)) {
+    var typeRef = (node && node.is$FunctionTypeReference());
+    var name = '';
+    if (typeRef.func.name != null) {
+      name = typeRef.func.name.name;
+    }
+    typeRef.type = this.get$library().getOrAddFunctionType(this, $assert_String(name), typeRef.func);
+  }
+  else {
+    $globals.world.internalError('unknown type reference', node.span);
+  }
+  return node.type;
+}
+lang_Element.prototype.hashCode$0 = lang_Element.prototype.hashCode;
+lang_Element.prototype.resolve$0 = lang_Element.prototype.resolve;
 // ********** Code for WorldGenerator **************
 function WorldGenerator(main, writer) {
   this.hasStatics = false
   this._inheritsGenerated = false
   this.main = main;
   this.writer = writer;
   this.globals = $map([]);
   this.corejs = new CoreJs();
   // Initializers done
 }
@@ skipping 136 matching lines @@
   this.writer.writeln(('' + onType.get$jsname() + '.prototype.is\$' + checkType.get$jsname() + ' = ') + ('' + value + ';'));
 }
 WorldGenerator.prototype.writeType = function(type) {
   var $0;
   if (type.name != null && (type instanceof ConcreteType) && $eq(type.get$library(), $globals.world.get$coreimpl()) && type.name.startsWith('ListFactory')) {
     this.writer.writeln(('' + type.get$jsname() + ' = ' + type.get$genericType().get$jsname() + ';'));
     return;
   }
   var typeName = type.get$jsname() != null ? type.get$jsname() : 'top level';
   this.writer.comment(('// ********** Code for ' + typeName + ' **************'));
-  if ($notnull_bool(type.get$isNativeType()) && !$notnull_bool(type.get$isTop())) {
+  if ($notnull_bool(type.get$isNative()) && !$notnull_bool(type.get$isTop())) {
     var nativeName = type.get$definition().get$nativeType().get$name();
     if ($notnull_bool($eq(nativeName, ''))) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
     else if (type.get$jsname() != nativeName) {
       this.writer.writeln(('' + type.get$jsname() + ' = ' + nativeName + ';'));
     }
   }
   if ($notnull_bool(type.get$isTop())) {
   }
   else if (type.get$constructors().get$length() == 0) {
-    if (!$notnull_bool(type.get$isNativeType())) {
+    if (!$notnull_bool(type.get$isNative())) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
   }
   else {
     var standardConstructor = (($0 = type.get$constructors().$index('')) && $0.is$Member());
     if (standardConstructor == null || standardConstructor.generator == null) {
-      if (!$notnull_bool(type.get$isNativeType())) {
+      if (!$notnull_bool(type.get$isNative())) {
         this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
       }
     }
     else {
       standardConstructor.generator.writeDefinition(this.writer, null);
     }
     var $list = type.get$constructors().getValues();
     for (var $i = type.get$constructors().getValues().iterator$0(); $i.hasNext$0(); ) {
       var c = $i.next$0();
       if ($notnull_bool($ne(c.get$generator(), null)) && $notnull_bool($ne(c, standardConstructor))) {
         c.get$generator().writeDefinition$2(this.writer);
       }
     }
   }
   if (!$notnull_bool(type.get$isTop())) {
     if ((type instanceof ConcreteType)) {
       var c = (type && type.is$ConcreteType());
       this._ensureInheritsHelper();
       this.writer.writeln(('\$inherits(' + c.get$jsname() + ', ' + c.genericType.get$jsname() + ');'));
       for (var p = c._parent;
        (p instanceof ConcreteType); p = p._parent) {
         this._ensureInheritMembersHelper();
         this._mixins.writeln(('\$inheritsMembers(' + c.get$jsname() + ', ' + p.get$jsname() + ');'));
       }
     }
-    else if (!$notnull_bool(type.get$isNativeType())) {
+    else if (!$notnull_bool(type.get$isNative())) {
       if (type.get$parent() != null && !$notnull_bool(type.get$parent().get$isObject())) {
         this._ensureInheritsHelper();
         this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$parent().get$jsname() + ');'));
       }
     }
   }
   if (!(type instanceof ConcreteType)) {
     this._maybeIsTest(type, type);
   }
   if (type.get$genericType()._concreteTypes != null) {
@@ skipping 362 matching lines @@
   if (this.captures != null && this.captures.get$length() > 0) {
     names = ListFactory.ListFactory$from$factory(this.captures);
     names.sort$1((function (x, y) {
       return x.compareTo$1(y);
     })
     );
     paramCode = ListFactory.ListFactory$from$factory((names && names.is$Iterable()));
     paramCode.addAll$1(this._paramCode);
   }
   var _params = ('(' + Strings.join(this._paramCode, ", ") + ')');
-  var params = ('(' + Strings.join((paramCode && paramCode.is$List$String()), ", ") + ')');
+  var params = ('(' + Strings.join((paramCode && paramCode.is$List_String()), ", ") + ')');
   if ($notnull_bool(this.method.declaringType.get$isTop()) && !$notnull_bool(this.get$isClosure())) {
     defWriter.enterBlock(('function ' + this.method.get$jsname() + params + ' {'));
   }
   else if ($notnull_bool(this.get$isClosure())) {
     if (this.method.name == '') {
       defWriter.enterBlock(('(function ' + params + ' {'));
     }
     else if ($notnull_bool($ne(names, null))) {
       if (lambda == null) {
         defWriter.enterBlock(('var ' + this.method.get$jsname() + ' = (function' + params + ' {'));
@@ skipping 30 matching lines @@
     $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 803, 14);
     this._freeTemps.addAll(this._usedTemps);
     this._freeTemps.sort((function (x, y) {
       return x.compareTo$1(y);
     })
     );
     defWriter.writeln(('var ' + Strings.join(this._freeTemps, ", ") + ';'));
   }
   defWriter.writeln(this.writer.get$text());
   if ($notnull_bool($ne(names, null))) {
-    defWriter.exitBlock(('}).bind(null, ' + Strings.join((names && names.is$List$String()), ", ") + ')'));
+    defWriter.exitBlock(('}).bind(null, ' + Strings.join((names && names.is$List_String()), ", ") + ')'));
   }
   else if ($notnull_bool(this.get$isClosure()) && this.method.name == '') {
     defWriter.exitBlock('})');
   }
   else {
     defWriter.exitBlock('}');
   }
   if ($notnull_bool(this.method.get$isConstructor()) && this.method.get$constructorName() != '') {
     defWriter.writeln(('' + this.method.declaringType.get$jsname() + '.' + this.method.get$constructorName() + '\$ctor.prototype = ') + ('' + this.method.declaringType.get$jsname() + '.prototype;'));
   }
@@ skipping 30 matching lines @@
         var start = '';
         if ($notnull_bool(meth.isStatic)) {
           if (!$notnull_bool(meth.declaringType.get$isTop())) {
             start = meth.declaringType.get$jsname() + '.';
           }
         }
         else {
           start = meth.declaringType.get$jsname() + '.prototype.';
         }
         optNames.addAll$1(optValues);
-        var optional = "['" + Strings.join((optNames && optNames.is$List$String()), "', '") + "']";
+        var optional = "['" + Strings.join((optNames && optNames.is$List_String()), "', '") + "']";
         defWriter.writeln(('' + start + meth.get$jsname() + '.\$optional = ' + optional));
       }
     }
   }
 }
 MethodGenerator.prototype.writeBody = function() {
   var $0;
   var initializers = null;
   var initializedFields = null;
   var allMembers = null;
@@ skipping 185 matching lines @@
 }
 MethodGenerator.prototype._pushBlock = function(reentrant) {
   this._scope = new BlockScope(this, this._scope, reentrant);
 }
 MethodGenerator.prototype._popBlock = function() {
   this._scope = this._scope.parent;
 }
 MethodGenerator.prototype._makeLambdaMethod = function(name, func) {
   var meth = new MethodMember(name, this.method.declaringType, func);
   meth.set$isLambda(true);
-  meth.resolve$1(this.method.declaringType);
+  meth.set$enclosingElement(this.method);
+  meth.resolve$0();
   $globals.world.gen.genMethod((meth && meth.is$Member()), this);
   return (meth && meth.is$MethodMember());
 }
 MethodGenerator.prototype.visitBool = function(node) {
   return this.visitValue(node).convertTo$3(this, $globals.world.nonNullBool, node);
 }
 MethodGenerator.prototype.visitValue = function(node) {
   if (node == null) return null;
   var value = node.visit(this);
   value.checkFirstClass$1(node.span);
@@ skipping 785 matching lines @@
       }
       else {
         argsCode.add$1(arg.get$canonicalCode());
       }
     }
     else {
       argsCode.add$1(arg.get$code());
     }
   }
   $globals.world.get$coreimpl().types.$index('ListFactory').markUsed$0();
-  var code = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
+  var code = ('[' + Strings.join((argsCode && argsCode.is$List_String()), ", ") + ']');
   var value = new Value($globals.world.listType, code, node.span, true);
   if ($notnull_bool(node.isConst)) {
     var immutableList = $globals.world.get$coreimpl().types.$index('ImmutableList');
     var immutableListCtor = immutableList.getConstructor$1('from');
     var result = immutableListCtor.invoke$4(this, node, new Value.type$ctor(value.get$type(), node.span), new Arguments(null, [value]));
-    value = $globals.world.gen.globalForConst(ConstListValue.ConstListValue$factory((immutableList && immutableList.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), ('const ' + code), $assert_String(result.get$code()), node.span), (argValues && argValues.is$List$Value()));
+    value = $globals.world.gen.globalForConst(ConstListValue.ConstListValue$factory((immutableList && immutableList.is$lang_Type()), (argValues && argValues.is$List_EvaluatedValue()), ('const ' + code), $assert_String(result.get$code()), node.span), (argValues && argValues.is$List_Value()));
   }
   return value;
 }
 MethodGenerator.prototype.visitMapExpression = function(node) {
   var $0;
   var mapImplType = $globals.world.gen.useMapFactory();
   var argValues = [];
   var argsCode = [];
   for (var i = 0;
    i < node.items.length; i += 2) {
@@ skipping 11 matching lines @@
       else {
         argsCode.add$1(key.get$canonicalCode());
         argsCode.add$1(value.get$canonicalCode());
       }
     }
     else {
       argsCode.add$1(key.get$code());
       argsCode.add$1(value.get$code());
     }
   }
-  var argList = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
+  var argList = ('[' + Strings.join((argsCode && argsCode.is$List_String()), ", ") + ']');
   var code = ('\$map(' + argList + ')');
   if ($notnull_bool(node.isConst)) {
     var immutableMap = $globals.world.get$coreimpl().types.$index('ImmutableMap');
     var immutableMapCtor = immutableMap.getConstructor$1('');
     var argsValue = new Value($globals.world.listType, argList, node.span, true);
     var result = immutableMapCtor.invoke$4(this, node, new Value.type$ctor(immutableMap, node.span), new Arguments(null, [argsValue]));
-    var value = ConstMapValue.ConstMapValue$factory((immutableMap && immutableMap.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), code, $assert_String(result.get$code()), node.span);
-    return $globals.world.gen.globalForConst(value, (argValues && argValues.is$List$Value()));
+    var value = ConstMapValue.ConstMapValue$factory((immutableMap && immutableMap.is$lang_Type()), (argValues && argValues.is$List_EvaluatedValue()), code, $assert_String(result.get$code()), node.span);
+    return $globals.world.gen.globalForConst(value, (argValues && argValues.is$List_Value()));
   }
   return new Value(mapImplType, code, node.span, true);
 }
 MethodGenerator.prototype.visitConditionalExpression = function(node) {
   var $0;
   var test = this.visitBool(node.test);
   var trueBranch = this.visitValue(node.trueBranch);
   var falseBranch = this.visitValue(node.falseBranch);
   var code = ('' + test.get$code() + ' ? ' + trueBranch.get$code() + ' : ' + falseBranch.get$code());
   return new Value(lang_Type.union((($0 = trueBranch.get$type()) && $0.is$lang_Type()), (($0 = falseBranch.get$type()) && $0.is$lang_Type())), code, node.span, true);
@@ skipping 42 matching lines @@
     var u = (item && item.is$UnaryExpression());
     return u.op.kind == 16/*TokenKind.INCR*/ || u.op.kind == 17/*TokenKind.DECR*/;
   }
   else {
     return false;
   }
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   var $0;
   var type = node.type.type;
-  $assert($ne(type, null), "type != null", "gen.dart", 2238, 12);
+  $assert($ne(type, null), "type != null", "gen.dart", 2239, 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.get$code();
       if ((item instanceof BinaryExpression) || (item instanceof ConditionalExpression) || (item instanceof PostfixExpression) || $notnull_bool(this._isUnaryIncrement((item && item.is$lang_Expression())))) {
         code = ('(' + code + ')');
       }
       if ($notnull_bool($eq(items.length, 0)) || ($notnull_bool($ne(code, "''")) && $notnull_bool($ne(code, '""')))) {
         items.add$1(code);
       }
     }
-    return new Value(type, ('(' + Strings.join((items && items.is$List$String()), " + ") + ')'), node.span, true);
+    return new Value(type, ('(' + Strings.join((items && items.is$List_String()), " + ") + ')'), node.span, true);
   }
   var text = node.text;
   if ($notnull_bool(type.get$isString())) {
     if ($notnull_bool(text.startsWith$1('@'))) {
       text = MethodGenerator._escapeString(parseStringLiteral($assert_String(text)));
       text = ('"' + text + '"');
     }
     else if ($notnull_bool(isMultilineString($assert_String(text)))) {
       text = parseStringLiteral($assert_String(text));
       text = text.replaceAll$2('\n', '\\n');
@@ skipping 81 matching lines @@
     }
   }
   return this._bareCount;
 }
 Arguments.prototype.getCode = function() {
   var argsCode = [];
   for (var i = 0;
    i < this.get$length(); i++) {
     argsCode.add$1(this.values.$index(i).get$code());
   }
-  Arguments.removeTrailingNulls((argsCode && argsCode.is$List$Value()));
-  return Strings.join((argsCode && argsCode.is$List$String()), ", ");
+  Arguments.removeTrailingNulls((argsCode && argsCode.is$List_Value()));
+  return Strings.join((argsCode && argsCode.is$List_String()), ", ");
 }
 Arguments.removeTrailingNulls = function(argsCode) {
   while (argsCode.length > 0 && $notnull_bool($eq(argsCode.last(), 'null'))) {
     argsCode.removeLast();
   }
 }
 Arguments.prototype.getNames = function() {
   var names = [];
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     names.add$1(this.getName(i));
   }
-  return (names && names.is$List$String());
+  return (names && names.is$List_String());
 }
 Arguments.prototype.toCallStubArgs = function() {
   var result = [];
   for (var i = 0;
    i < this.get$bareCount(); i++) {
     result.add$1(new Value($globals.world.varType, ('\$' + i), null, false));
   }
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     var name = this.getName(i);
@@ skipping 11 matching lines @@
 LibraryImport.prototype.get$prefix = function() { return this.prefix; };
 LibraryImport.prototype.set$prefix = function(value) { return this.prefix = value; };
 LibraryImport.prototype.get$library = function() { return this.library; };
 LibraryImport.prototype.set$library = function(value) { return this.library = value; };
 // ********** Code for Library **************
 function Library(baseSource) {
   this.isWritten = false
   this.isMarked = false
   this.baseSource = baseSource;
   // Initializers done
+  lang_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 = $map([]);
 }
+$inherits(Library, lang_Element);
 Library.prototype.is$Library = function(){return this;};
 Library.prototype.get$baseSource = function() { return this.baseSource; };
 Library.prototype.get$types = function() { return this.types; };
 Library.prototype.set$types = function(value) { return this.types = value; };
-Library.prototype.get$name = function() { return this.name; };
-Library.prototype.set$name = function(value) { return this.name = value; };
 Library.prototype.get$topType = function() { return this.topType; };
 Library.prototype.set$topType = function(value) { return this.topType = value; };
+Library.prototype.get$enclosingElement = function() {
+  return null;
+}
+Library.prototype.get$library = function() {
+  return this;
+}
+Library.prototype.get$isNative = function() {
+  return this.topType.isNative;
+}
 Library.prototype.get$isCore = function() {
   return $eq(this, $globals.world.corelib);
 }
 Library.prototype.get$isCoreImpl = function() {
   return $eq(this, $globals.world.get$coreimpl());
 }
-Library.prototype.get$jsname = function() {
-  if (this._jsname == null) {
-    this._jsname = this.name.replaceAll('.', '_').replaceAll(':', '_').replaceAll(' ', '_');
-  }
-  return this._jsname;
-}
 Library.prototype.get$span = function() {
   return new SourceSpan(this.baseSource, 0, 0);
 }
 Library.prototype.makeFullPath = function(filename) {
   if (filename.startsWith('dart:')) return filename;
   if (filename.startsWith('/')) return filename;
   if (filename.startsWith('file:///')) return filename;
   if (filename.startsWith('http://')) return filename;
   return joinPaths(this.sourceDir, filename);
 }
@@ skipping 20 matching lines @@
       if ($notnull_bool(member.declaringType.get$isTop())) {
         $globals.world._addTopName(member);
       }
       return;
     }
     var mset = this._privateMembers.$index(member.name);
     if ($notnull_bool(mset == null)) {
       var $list = $globals.world.libraries.getValues();
       for (var $i = $globals.world.libraries.getValues().iterator$0(); $i.hasNext$0(); ) {
         var lib = $i.next$0();
-        if (lib._privateMembers.containsKey(member.name)) {
-          member.set$jsname(('_' + this.get$jsname() + member.name));
+        if (lib._privateMembers.containsKey(member.get$jsname())) {
+          member._jsname = ('_' + this.get$jsname() + member.get$jsname());
           break;
         }
       }
       mset = new MemberSet(member, false);
       this._privateMembers.$setindex(member.name, mset);
     }
     else {
       mset.get$members().add$1(member);
     }
   }
   else {
     $globals.world._addMember(member);
   }
 }
-Library.prototype.getOrAddFunctionType = function(name, func, inType) {
+Library.prototype.getOrAddFunctionType = function(enclosingElement, name, func) {
   var def = new FunctionTypeDefinition(func, null, func.span);
   var type = new DefinedType(name, this, def, false);
   type.addMethod('\$call', func);
-  type.members.$index('\$call').resolve$1(inType);
+  var m = type.members.$index('\$call');
+  m.set$enclosingElement(enclosingElement);
+  m.resolve$0();
   type.interfaces = [$globals.world.functionType];
   return type;
 }
 Library.prototype.addType = function(name, definition, isClass) {
   var $0;
   if (this.types.containsKey(name)) {
     var existingType = this.types.$index(name);
     if ($notnull_bool(this.get$isCore()) && $notnull_bool(existingType.get$definition() == null)) {
       existingType.setDefinition$1(definition);
     }
@@ skipping 37 matching lines @@
       if ($notnull_bool($ne(ret, null)) && $notnull_bool($ne(ret, newRet))) {
         $globals.world.error(('conflicting types for "' + name + '"'), (($0 = ret.get$span()) && $0.is$SourceSpan()), (($0 = newRet.get$span()) && $0.is$SourceSpan()));
       }
       else {
         ret = newRet;
       }
     }
   }
   return (ret && ret.is$lang_Type());
 }
+Library.prototype.resolveType = function(node, typeErrors) {
+  if (node == null) return $globals.world.varType;
+  if (node.type != null) return node.type;
+  node.type = this.findType((node && node.is$NameTypeReference()));
+  if (node.type == null) {
+    var message = ('cannot find type ' + Library._getDottedName((node && node.is$NameTypeReference())));
+    if ($notnull_bool(typeErrors)) {
+      $globals.world.error($assert_String(message), node.span);
+      node.type = $globals.world.objectType;
+    }
+    else {
+      $globals.world.warning($assert_String(message), node.span);
+      node.type = $globals.world.varType;
+    }
+  }
+  return node.type;
+}
+Library._getDottedName = function(type) {
+  if (type.names != null) {
+    var names = map(type.names, (function (n) {
+      return n.get$name();
+    })
+    );
+    return type.name.name + '.' + Strings.join((names && names.is$List_String()), '.');
+  }
+  else {
+    return type.name.name;
+  }
+}
 Library.prototype.lookup = function(name, span) {
   var $0;
   var retType = this.findTypeByName(name);
   var ret = null;
   if ($notnull_bool($ne(retType, null))) {
     ret = retType.get$typeMember();
   }
   var newRet = this.topType.getMember(name);
   if ($notnull_bool($ne(newRet, null))) {
     if ($notnull_bool($ne(ret, null)) && $notnull_bool($ne(ret, newRet))) {
@@ skipping 25 matching lines @@
     this.name = this.baseSource.filename;
     var index = this.name.lastIndexOf('/', this.name.length);
     if (index >= 0) {
       this.name = this.name.substring($assert_num(index + 1));
     }
     index = this.name.indexOf('.', 0);
     if (index > 0) {
       this.name = this.name.substring(0, $assert_num(index));
     }
   }
+  this._jsname = this.name.replaceAll('.', '_').replaceAll(':', '_').replaceAll(' ', '_');
   var $list = this.types.getValues();
   for (var $i = this.types.getValues().iterator$0(); $i.hasNext$0(); ) {
     var type = $i.next$0();
     type.resolve$0();
   }
 }
 Library.prototype.visitSources = function() {
   var visitor = new _LibraryVisitor(this);
   visitor.addSource$1(this.baseSource);
 }
@@ skipping 46 matching lines @@
     $globals.world.error(('duplicate source file "' + source.filename + '"'));
     return;
   }
   this.library.sources.add(source);
   var parser = new lang_Parser(source, $globals.options.dietParse, false, false, 0);
   var unit = parser.compilationUnit();
   unit.forEach((function (def) {
     return def.visit$1($this);
   })
   );
-  $assert(this.sources.length == 0 || $notnull_bool(this.isTop), "sources.length == 0 || isTop", "library.dart", 299, 12);
+  $assert(this.sources.length == 0 || $notnull_bool(this.isTop), "sources.length == 0 || isTop", "library.dart", 330, 12);
   this.isTop = false;
   var newSources = this.sources;
   this.sources = [];
   for (var $i = newSources.iterator$0(); $i.hasNext$0(); ) {
     var source0 = $i.next$0();
     this.addSource((source0 && source0.is$SourceFile()));
   }
 }
 _LibraryVisitor.prototype.visitDirectiveDefinition = function(node) {
   if (!$notnull_bool(this.isTop)) {
     $globals.world.error('directives not allowed in sourced file', node.span);
     return;
   }
   var name;
   switch (node.name.name) {
     case "library":
 
       name = this.getSingleStringArg(node);
       if (this.library.name == null) {
         this.library.name = $assert_String(name);
         if ($notnull_bool($eq(name, 'node')) || $notnull_bool($eq(name, 'dom'))) {
-          this.library.topType.isNativeType = true;
+          this.library.topType.isNative = true;
         }
         if ($notnull_bool(this.seenImport) || $notnull_bool(this.seenSource) || $notnull_bool(this.seenResource)) {
           $globals.world.error('#library must be first directive in file', node.span);
         }
       }
       else {
         $globals.world.error('already specified library name', node.span);
       }
       break;
 
@@ skipping 108 matching lines @@
   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$2('\$call', node.func);
 }
 _LibraryVisitor.prototype.addSource$1 = function($0) {
   return this.addSource(($0 && $0.is$SourceFile()));
 };
 // ********** Code for Parameter **************
-function Parameter(definition) {
+function Parameter(definition, method) {
   this.isInitializer = false
   this.definition = definition;
+  this.method = method;
   // Initializers done
 }
 Parameter.prototype.is$Parameter = function(){return this;};
 Parameter.prototype.get$definition = function() { return this.definition; };
 Parameter.prototype.set$definition = function(value) { return this.definition = value; };
 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.set$type = function(value) { return this.type = value; };
 Parameter.prototype.get$isInitializer = function() { return this.isInitializer; };
 Parameter.prototype.set$isInitializer = function(value) { return this.isInitializer = value; };
 Parameter.prototype.get$value = function() { return this.value; };
 Parameter.prototype.set$value = function(value) { return this.value = value; };
-Parameter.prototype.resolve = function(method, inType) {
+Parameter.prototype.resolve = function() {
   this.name = this.definition.name.name;
   if (this.name.startsWith('this.')) {
     this.name = this.name.substring(5);
     this.isInitializer = true;
   }
-  this.type = inType.resolveType(this.definition.type, false);
-  if ($notnull_bool(method.get$isStatic()) && $notnull_bool(this.type.get$hasTypeParams())) {
+  this.type = this.method.resolveType(this.definition.type, false);
+  if ($notnull_bool(this.method.get$isStatic()) && this.method.get$typeParameters() == null && $notnull_bool(this.type.get$hasTypeParams())) {
     $globals.world.error('using type parameter in static context', this.definition.span);
   }
   if (this.definition.value != null) {
     if ((this.definition.value instanceof NullExpression) && this.definition.value.span.start == this.definition.span.start) {
       return;
     }
-    if (method.name == '\$call') {
-      if ($notnull_bool(method.get$definition().get$body() == null)) {
+    if (this.method.name == '\$call') {
+      if ($notnull_bool(this.method.get$definition().get$body() == null)) {
         $globals.world.error('default value not allowed on function type', this.definition.span);
       }
     }
-    else if ($notnull_bool(method.get$isAbstract())) {
+    else if ($notnull_bool(this.method.get$isAbstract())) {
       $globals.world.error('default value not allowed on abstract methods', this.definition.span);
     }
   }
-  else if ($notnull_bool(this.isInitializer) && !$notnull_bool(method.get$isConstructor())) {
+  else if ($notnull_bool(this.isInitializer) && !$notnull_bool(this.method.get$isConstructor())) {
     $globals.world.error('initializer parameters only allowed on constructors', this.definition.span);
   }
 }
 Parameter.prototype.genValue = function(method, context) {
   var $0;
   if (this.definition.value == null || this.value != null) return;
   if (context == null) {
     context = new MethodGenerator(method, null);
   }
   this.value = (($0 = this.definition.value.visit(context)) && $0.is$Value());
   this.value = this.value.convertTo(context, this.type, this.definition.value, false);
 }
-Parameter.prototype.copyWithNewType = function(newType) {
+Parameter.prototype.copyWithNewType = function(newMethod, newType) {
   var $0;
-  var ret = new Parameter(this.definition);
+  var ret = new Parameter(this.definition, newMethod);
   ret.set$type(newType);
   ret.set$name(this.name);
   ret.set$isInitializer(this.isInitializer);
   return (ret && ret.is$Parameter());
 }
 Parameter.prototype.get$isOptional = function() {
   return this.definition != null && this.definition.value != null;
 }
-Parameter.prototype.copyWithNewType$1 = function($0) {
-  return this.copyWithNewType(($0 && $0.is$lang_Type()));
+Parameter.prototype.copyWithNewType$2 = function($0, $1) {
+  return this.copyWithNewType(($0 && $0.is$Member()), ($1 && $1.is$lang_Type()));
 };
 Parameter.prototype.genValue$2 = function($0, $1) {
   return this.genValue(($0 && $0.is$MethodMember()), ($1 && $1.is$MethodGenerator()));
 };
-Parameter.prototype.resolve$2 = function($0, $1) {
-  return this.resolve(($0 && $0.is$Member()), ($1 && $1.is$lang_Type()));
-};
+Parameter.prototype.resolve$0 = Parameter.prototype.resolve;
 // ********** Code for Member **************
 function Member(name, declaringType) {
-  this.name = name;
+  this.isGenerated = false;
   this.declaringType = declaringType;
-  this.isGenerated = false;
   // Initializers done
+  lang_Element.call(this, name, declaringType);
 }
+$inherits(Member, lang_Element);
 Member.prototype.is$Member = function(){return this;};
-Member.prototype.is$Named = function(){return this;};
-Member.prototype.get$name = function() { return this.name; };
 Member.prototype.get$declaringType = function() { return this.declaringType; };
 Member.prototype.get$generator = function() { return this.generator; };
 Member.prototype.set$generator = function(value) { return this.generator = value; };
-Member.prototype.get$jsname = function() {
-  return this._jsname == null ? this.name : this._jsname;
-}
-Member.prototype.set$jsname = function(name) {
-  return this._jsname = name;
-}
 Member.prototype.get$library = function() {
   return this.declaringType.get$library();
 }
 Member.prototype.get$isPrivate = function() {
   return this.name.startsWith('_');
 }
 Member.prototype.get$isConstructor = function() {
   return false;
 }
 Member.prototype.get$isField = function() {
@@ skipping 76 matching lines @@
     $globals.world.error('static members can not hide parent members', this.get$span(), other.get$span());
     return false;
   }
   else if ($notnull_bool(other.get$isStatic())) {
     $globals.world.error('can not override static member', this.get$span(), other.get$span());
     return false;
   }
   return true;
 }
 Member.prototype.get$generatedFactoryName = function() {
-  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 205, 12);
+  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 187, 12);
   var prefix = ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$');
   if (this.name == '') {
     return ('' + prefix + 'factory');
   }
   else {
     return ('' + prefix + this.name + '\$factory');
   }
 }
-Member.prototype.resolveType = function(node, isRequired) {
-  var type = this.declaringType.resolveType(node, isRequired);
-  if ($notnull_bool(this.get$isStatic()) && $notnull_bool(type.get$hasTypeParams())) {
-    $globals.world.error('using type parameter in static context', node.span);
-  }
-  return (type && type.is$lang_Type());
-}
 Member.prototype.hashCode = function() {
   return (this.declaringType.hashCode() << 4) ^ this.name.hashCode();
 }
 Member.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()));
 };
 Member.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()));
 };
 Member.prototype.canInvoke$2 = function($0, $1) {
   return this.canInvoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Arguments()));
 };
 Member.prototype.computeValue$0 = Member.prototype.computeValue;
 Member.prototype.hashCode$0 = Member.prototype.hashCode;
 Member.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()), false);
 };
 Member.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 Member.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
 Member.prototype.provideFieldSyntax$0 = Member.prototype.provideFieldSyntax;
 Member.prototype.providePropertySyntax$0 = Member.prototype.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);
 }
 $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;
 }
 TypeMember.prototype.get$returnType = function() {
   return $globals.world.varType;
 }
 TypeMember.prototype.canInvoke = function(context, args) {
   return false;
 }
 TypeMember.prototype.get$canGet = function() {
   return true;
 }
 TypeMember.prototype.get$canSet = function() {
   return false;
 }
-TypeMember.prototype.resolve = function(inType) {
-
-}
 TypeMember.prototype._get = function(context, node, target, isDynamic) {
   return new Value.type$ctor(this.type, node.span);
 }
 TypeMember.prototype._set = function(context, node, target, value, isDynamic) {
   $globals.world.error('cannot set type', node.span);
 }
 TypeMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   $globals.world.error('cannot invoke type', node.span);
 }
 TypeMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 TypeMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 TypeMember.prototype.canInvoke$2 = function($0, $1) {
   return this.canInvoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Arguments()));
 };
 TypeMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 };
 TypeMember.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 TypeMember.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
-TypeMember.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$lang_Type()));
-};
 // ********** Code for FieldMember **************
 function FieldMember(name, declaringType, definition, value) {
   this._providePropertySyntax = false
   this._computing = false
   this.definition = definition;
   this.value = value;
   this.isNative = false;
   // Initializers done
   Member.call(this, name, declaringType);
 }
@@ skipping 40 matching lines @@
 }
 FieldMember.prototype.get$canGet = function() {
   return true;
 }
 FieldMember.prototype.get$canSet = function() {
   return !$notnull_bool(this.isFinal);
 }
 FieldMember.prototype.get$isField = function() {
   return true;
 }
-FieldMember.prototype.resolve = function(inType) {
+FieldMember.prototype.resolve = function() {
   var $0;
   this.isStatic = this.declaringType.get$isTop();
   this.isFinal = false;
   if (this.definition.modifiers != null) {
     var $list = this.definition.modifiers;
     for (var $i = 0;$i < $list.length; $i++) {
       var mod = $list.$index($i);
       if ($notnull_bool($eq(mod.get$kind(), 86/*TokenKind.STATIC*/))) {
         if ($notnull_bool(this.isStatic)) {
           $globals.world.error('duplicate static modifier', (($0 = mod.get$span()) && $0.is$SourceSpan()));
         }
         this.isStatic = true;
       }
       else if ($notnull_bool($eq(mod.get$kind(), 97/*TokenKind.FINAL*/))) {
         if ($notnull_bool(this.isFinal)) {
           $globals.world.error('duplicate final modifier', (($0 = mod.get$span()) && $0.is$SourceSpan()));
         }
         this.isFinal = true;
       }
       else {
         $globals.world.error(('' + mod + ' modifier not allowed on field'), (($0 = mod.get$span()) && $0.is$SourceSpan()));
       }
     }
   }
-  this.type = inType.resolveType(this.definition.type, false);
+  this.type = this.resolveType(this.definition.type, false);
   if ($notnull_bool(this.isStatic) && $notnull_bool(this.type.get$hasTypeParams())) {
     $globals.world.error('using type parameter in static context', this.definition.type.span);
   }
   if ($notnull_bool(this.isStatic) && $notnull_bool(this.isFinal) && this.value == null) {
     $globals.world.error('static final field is missing initializer', this.get$span());
   }
   this.get$library()._addMember(this);
 }
 FieldMember.prototype.computeValue = function() {
   var $0;
@@ skipping 70 matching lines @@
 }
 FieldMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 FieldMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 FieldMember.prototype.computeValue$0 = FieldMember.prototype.computeValue;
 FieldMember.prototype.provideFieldSyntax$0 = FieldMember.prototype.provideFieldSyntax;
 FieldMember.prototype.providePropertySyntax$0 = FieldMember.prototype.providePropertySyntax;
-FieldMember.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$lang_Type()));
-};
+FieldMember.prototype.resolve$0 = FieldMember.prototype.resolve;
 // ********** Code for PropertyMember **************
 function PropertyMember(name, declaringType) {
   this._provideFieldSyntax = false
   // Initializers done
   Member.call(this, name, declaringType);
 }
 $inherits(PropertyMember, Member);
 PropertyMember.prototype.is$PropertyMember = function(){return this;};
 PropertyMember.prototype.get$getter = function() { return this.getter; };
 PropertyMember.prototype.set$getter = function(value) { return this.getter = value; };
@@ skipping 66 matching lines @@
   if ((parentMember instanceof ConcreteMember)) {
     var c = (parentMember && parentMember.is$ConcreteMember());
     parent = (($0 = c.baseMember) && $0.is$PropertyMember());
   }
   else {
     parent = (parentMember && parentMember.is$PropertyMember());
   }
   if (this.getter == null) this.getter = parent.getter;
   if (this.setter == null) this.setter = parent.setter;
 }
-PropertyMember.prototype.resolve = function(inType) {
-  if (this.getter != null) this.getter.resolve(inType);
-  if (this.setter != null) this.setter.resolve(inType);
+PropertyMember.prototype.resolve = function() {
+  if (this.getter != null) this.getter.resolve();
+  if (this.setter != null) this.setter.resolve();
   this.get$library()._addMember(this);
 }
 PropertyMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 PropertyMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 PropertyMember.prototype.provideFieldSyntax$0 = PropertyMember.prototype.provideFieldSyntax;
 PropertyMember.prototype.providePropertySyntax$0 = PropertyMember.prototype.providePropertySyntax;
-PropertyMember.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$lang_Type()));
-};
+PropertyMember.prototype.resolve$0 = PropertyMember.prototype.resolve;
 // ********** Code for ConcreteMember **************
 function ConcreteMember(name, declaringType, baseMember) {
   this.baseMember = baseMember;
   // Initializers done
   Member.call(this, name, declaringType);
   this.parameters = [];
   this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType);
   var $list = this.baseMember.get$parameters();
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
     var newType = p.get$type().resolveTypeParams$1(declaringType);
     if ($notnull_bool($ne(newType, p.get$type()))) {
-      this.parameters.add(p.copyWithNewType$1(newType));
+      this.parameters.add(p.copyWithNewType$2(this, newType));
     }
     else {
       this.parameters.add(p);
     }
   }
 }
 $inherits(ConcreteMember, Member);
 ConcreteMember.prototype.is$ConcreteMember = function(){return this;};
 ConcreteMember.prototype.get$returnType = function() { return this.returnType; };
 ConcreteMember.prototype.set$returnType = function(value) { return this.returnType = value; };
@@ skipping 13 matching lines @@
 }
 ConcreteMember.prototype.get$isFactory = function() {
   return this.baseMember.get$isFactory();
 }
 ConcreteMember.prototype.get$isFinal = function() {
   return this.baseMember.get$isFinal();
 }
 ConcreteMember.prototype.get$jsname = function() {
   return this.baseMember.get$jsname();
 }
-ConcreteMember.prototype.set$jsname = function(name) {
-  return $globals.world.internalError('bad set of jsname on ConcreteMember');
-}
 ConcreteMember.prototype.get$canGet = function() {
   return this.baseMember.get$canGet();
 }
 ConcreteMember.prototype.get$canSet = function() {
   return this.baseMember.get$canSet();
 }
 ConcreteMember.prototype.canInvoke = function(context, args) {
   return this.baseMember.canInvoke(context, args);
 }
 ConcreteMember.prototype.get$isField = function() {
@@ skipping 99 matching lines @@
   Member.call(this, name, declaringType);
 }
 $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$typeParameters = function() { return this.typeParameters; };
+MethodMember.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 MethodMember.prototype.get$isStatic = function() { return this.isStatic; };
 MethodMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 MethodMember.prototype.get$isAbstract = function() { return this.isAbstract; };
 MethodMember.prototype.set$isAbstract = function(value) { return this.isAbstract = value; };
 MethodMember.prototype.get$isConst = function() { return this.isConst; };
 MethodMember.prototype.set$isConst = function(value) { return this.isConst = value; };
 MethodMember.prototype.get$isFactory = function() { return this.isFactory; };
 MethodMember.prototype.set$isFactory = function(value) { return this.isFactory = value; };
 MethodMember.prototype.get$isLambda = function() { return this.isLambda; };
 MethodMember.prototype.set$isLambda = function(value) { return this.isLambda = value; };
@@ skipping 12 matching lines @@
   return false;
 }
 MethodMember.prototype.get$canSet = function() {
   return false;
 }
 MethodMember.prototype.get$span = function() {
   var $0;
   return (($0 = this.definition == null ? null : this.definition.span) && $0.is$SourceSpan());
 }
 MethodMember.prototype.get$constructorName = function() {
-  var $0;
-  var returnType = (($0 = this.definition.returnType) && $0.is$NameTypeReference());
-  if (returnType == null) return '';
-  if (returnType.names != null) {
-    return $assert_String(returnType.names.$index(0).get$name());
+  var returnType = this.definition.returnType;
+  if ($notnull_bool(returnType == null)) return '';
+  if ((returnType instanceof GenericTypeReference)) {
+    return '';
   }
-  else if (returnType.name != null) {
-    return returnType.name.name;
+  if ($notnull_bool($ne(returnType.get$names(), null))) {
+    return $assert_String(returnType.get$names().$index(0).get$name());
+  }
+  else if ($notnull_bool($ne(returnType.get$name(), null))) {
+    return $assert_String(returnType.get$name().get$name());
   }
   $globals.world.internalError('no valid constructor name', this.definition.span);
 }
 MethodMember.prototype.get$functionType = function() {
   if (this._functionType == null) {
-    this._functionType = this.get$library().getOrAddFunctionType(this.name, this.definition, this.declaringType);
+    this._functionType = this.get$library().getOrAddFunctionType(this.declaringType, this.name, this.definition);
     if (this.parameters == null) {
-      this.resolve(this.declaringType);
+      this.resolve();
     }
   }
   return this._functionType;
 }
 MethodMember.prototype.override = function(other) {
   if (!$notnull_bool(Member.prototype.override.call(this, other))) return false;
   if ($notnull_bool(other.get$isMethod())) {
     return true;
   }
   else {
@@ skipping 106 matching lines @@
   var $list = this.parameters;
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
     p.genValue$2(this, this.generator);
   }
 }
 MethodMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   var $0;
   if (this.parameters == null) {
     $globals.world.info(('surprised to need to resolve: ' + this.declaringType.name + '.' + this.name));
-    this.resolve(this.declaringType);
+    this.resolve();
   }
   this.declaringType.genMethod(this);
   if ($notnull_bool(this.isStatic) || $notnull_bool(this.isFactory)) {
     this.declaringType.markUsed();
   }
   if ($notnull_bool(this.get$isNative()) && this.returnType != null) this.returnType.markUsed();
   if (!$notnull_bool(this.namesInOrder(args))) {
     return context.findMembers(this.name).invokeOnVar(context, node, target, args);
   }
   var argsCode = [];
@@ skipping 49 matching lines @@
         var p = this.indexOfParameter($assert_String(name));
         if (p < 0) {
           return this._argError(context, node, target, args, ('method does not have optional parameter "' + name + '"'));
         }
         else if (p < bareCount) {
           return this._argError(context, node, target, args, ('argument "' + name + '" passed as positional and named'));
         }
       }
       $globals.world.internalError(('wrong named arguments calling ' + this.name), node.span);
     }
-    Arguments.removeTrailingNulls((argsCode && argsCode.is$List$Value()));
+    Arguments.removeTrailingNulls((argsCode && argsCode.is$List_Value()));
   }
-  var argsString = Strings.join((argsCode && argsCode.is$List$String()), ', ');
+  var argsString = Strings.join((argsCode && argsCode.is$List_String()), ', ');
   if ($notnull_bool(this.get$isConstructor())) {
     return this._invokeConstructor(context, node, target, args, argsString);
   }
   if ($notnull_bool(target.isSuper)) {
     return new Value(this.get$inferredResult(), ('' + this.declaringType.get$jsname() + '.prototype.' + this.get$jsname() + '.call(' + argsString + ')'), node.span, true);
   }
   if ($notnull_bool(this.get$isOperator())) {
     return this._invokeBuiltin(context, node, target, args, argsCode, isDynamic);
   }
   if ($notnull_bool(this.isFactory)) {
-    $assert(target.isType, "target.isType", "member.dart", 969, 14);
+    $assert(target.isType, "target.isType", "member.dart", 945, 14);
     return new Value(target.type, ('' + this.get$generatedFactoryName() + '(' + argsString + ')'), node.span, true);
   }
   if ($notnull_bool(this.isStatic)) {
     if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.get$inferredResult(), ('' + this.get$jsname() + '(' + argsString + ')'), node != null ? node.span : node, true);
     }
     return new Value(this.get$inferredResult(), ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
   }
   var code = ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')');
   if ($notnull_bool(target.get$isConst())) {
@@ skipping 66 matching lines @@
         if ($notnull_bool(value == null)) {
           value = this.parameters.$index(j).get$value();
         }
       }
       this.generator._scope._vars.$setindex(name, value);
     }
     var $list = this.definition.initializers;
     for (var $i = 0;$i < $list.length; $i++) {
       var init = $list.$index($i);
       if ((init instanceof CallExpression)) {
-        var delegateArgs = this.generator._makeArgs((($0 = init.get$arguments()) && $0.is$List$ArgumentNode()));
+        var delegateArgs = this.generator._makeArgs((($0 = init.get$arguments()) && $0.is$List_ArgumentNode()));
         var value = this.initDelegate.invoke(this.generator, node, target, (delegateArgs && delegateArgs.is$Arguments()), false);
         if ((init.get$target() instanceof ThisExpression)) {
           return (value && value.is$Value());
         }
         else {
           if ((value instanceof GlobalValue)) {
             value = value.get$exp();
           }
           var $list0 = value.get$fields().getKeys$0();
           for (var $i0 = value.get$fields().getKeys$0().iterator$0(); $i0.hasNext$0(); ) {
@@ skipping 172 matching lines @@
           val1 = val1.substring$2(1, val1.length - 1);
         }
         var value = ('' + val0 + val1);
         value = '"' + value.replaceAll$2('"', '\\"') + '"';
         return EvaluatedValue.EvaluatedValue$factory($globals.world.stringType, value, $assert_String(value), node.span);
       }
       args.values.$index(0).invoke$4(context, 'toString', node, Arguments.get$EMPTY());
       return new Value(this.declaringType, ('' + target.code + ' + ' + argsCode.$index(0)), node.span, true);
     }
   }
-  else if ($notnull_bool(this.declaringType.get$isNativeType())) {
+  else if ($notnull_bool(this.declaringType.get$isNative())) {
     if (this.name == '\$index') {
       return new Value(this.returnType, ('' + target.code + '[' + argsCode.$index(0) + ']'), node.span, true);
     }
     else if (this.name == '\$setindex') {
       return new Value(this.returnType, ('' + target.code + '[' + argsCode.$index(0) + '] = ' + argsCode.$index(1)), node.span, true);
     }
   }
   if (this.name == '\$eq' || this.name == '\$ne') {
     var op = this.name == '\$eq' ? '==' : '!=';
     if (this.name == '\$ne') {
       target.invoke(context, '\$eq', node, args, isDynamic);
     }
     if ($notnull_bool(allConst)) {
       var val0 = target.get$dynamic().get$actualValue();
       var val1 = args.values.$index(0).get$dynamic().get$actualValue();
       var newVal = this.name == '\$eq' ? $eq(val0, val1) : $ne(val0, val1);
       return EvaluatedValue.EvaluatedValue$factory($globals.world.nonNullBool, newVal, ("" + newVal), node.span);
     }
     if ($notnull_bool($eq(argsCode.$index(0), 'null'))) {
       return new Value(this.get$inferredResult(), ('' + target.code + ' ' + op + ' null'), node.span, true);
     }
     else if ($notnull_bool(target.type.get$isNum()) || $notnull_bool(target.type.get$isString())) {
       return new Value(this.get$inferredResult(), ('' + target.code + ' ' + op + ' ' + argsCode.$index(0)), node.span, true);
     }
     $globals.world.gen.corejs.useOperator(this.name);
     return new Value(this.get$inferredResult(), ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')'), node.span, true);
   }
   if ($notnull_bool(this.get$isCallMethod())) {
     this.declaringType.markUsed();
-    return new Value(this.get$inferredResult(), ('' + target.code + '(' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ')'), node.span, true);
+    return new Value(this.get$inferredResult(), ('' + target.code + '(' + Strings.join((argsCode && argsCode.is$List_String()), ", ") + ')'), node.span, true);
   }
   if (this.name == '\$index') {
     $globals.world.gen.corejs.useIndex = true;
   }
   else if (this.name == '\$setindex') {
     $globals.world.gen.corejs.useSetIndex = true;
   }
-  var argsString = Strings.join((argsCode && argsCode.is$List$String()), ', ');
+  var argsString = Strings.join((argsCode && argsCode.is$List_String()), ', ');
   return new Value(this.get$inferredResult(), ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
 }
-MethodMember.prototype.resolve = function(inType) {
+MethodMember.prototype.resolve = function() {
   var $0;
-  this.isStatic = inType.get$isTop();
+  this.isStatic = this.declaringType.get$isTop();
   this.isConst = false;
   this.isFactory = false;
   this.isAbstract = !$notnull_bool(this.declaringType.get$isClass());
   if (this.definition.modifiers != null) {
     var $list = this.definition.modifiers;
     for (var $i = 0;$i < $list.length; $i++) {
       var mod = $list.$index($i);
       if ($notnull_bool($eq(mod.get$kind(), 86/*TokenKind.STATIC*/))) {
         if ($notnull_bool(this.isStatic)) {
           $globals.world.error('duplicate static modifier', (($0 = mod.get$span()) && $0.is$SourceSpan()));
@@ skipping 24 matching lines @@
         this.isAbstract = true;
       }
       else {
         $globals.world.error(('' + mod + ' modifier not allowed on method'), (($0 = mod.get$span()) && $0.is$SourceSpan()));
       }
     }
   }
   if ($notnull_bool(this.isFactory)) {
     this.isStatic = true;
   }
+  if (this.definition.typeParameters != null) {
+    if (!$notnull_bool(this.isFactory)) {
+      $globals.world.error('Only factories are allowed to have explicit type parameters', (($0 = this.definition.typeParameters.$index(0).get$span()) && $0.is$SourceSpan()));
+    }
+    else {
+      this.typeParameters = this.definition.typeParameters;
+      var $list = this.definition.typeParameters;
+      for (var $i = 0;$i < $list.length; $i++) {
+        var tp = $list.$index($i);
+        tp.set$enclosingElement(this);
+        tp.resolve$0();
+      }
+    }
+  }
   if ($notnull_bool(this.get$isOperator()) && $notnull_bool(this.isStatic) && !$notnull_bool(this.get$isCallMethod())) {
     $globals.world.error(('operator method may not be static "' + this.name + '"'), this.get$span());
   }
   if ($notnull_bool(this.isAbstract)) {
     if (this.definition.body != null && !(this.declaringType.get$definition() instanceof FunctionTypeDefinition)) {
       $globals.world.error('abstract method can not have a body', this.get$span());
     }
     if ($notnull_bool(this.isStatic) && !(this.declaringType.get$definition() instanceof FunctionTypeDefinition)) {
       $globals.world.error('static method can not be abstract', this.get$span());
     }
   }
   else {
     if (this.definition.body == null && !$notnull_bool(this.get$isConstructor())) {
       $globals.world.error('method needs a body', this.get$span());
     }
   }
-  if ($notnull_bool(this.get$isConstructor())) {
+  if ($notnull_bool(this.get$isConstructor()) && !$notnull_bool(this.isFactory)) {
     this.returnType = this.declaringType;
   }
   else {
-    this.returnType = inType.resolveType(this.definition.returnType, false);
-    if ($notnull_bool(this.isStatic) && $notnull_bool(this.returnType.get$hasTypeParams())) {
-      $globals.world.error('using type parameter in static context', this.definition.returnType.span);
-    }
+    this.returnType = this.resolveType(this.definition.returnType, false);
   }
   this.parameters = [];
   var $list = this.definition.formals;
   for (var $i = 0;$i < $list.length; $i++) {
     var formal = $list.$index($i);
-    var param = new Parameter(formal);
-    param.resolve$2(this, inType);
+    var param = new Parameter(formal, this);
+    param.resolve$0();
     this.parameters.add(param);
   }
   if (!$notnull_bool(this.isLambda)) {
     this.get$library()._addMember(this);
   }
 }
-MethodMember.prototype.findTypeVariable = function(node, isRequired) {
-  if (!$notnull_bool(this.isFactory) || !(node instanceof NameTypeReference)) {
-    return Member.prototype.resolveType.call(this, node, isRequired);
-  }
-  else {
-    return Member.prototype.resolveType.call(this, node, false);
-  }
-}
-MethodMember.prototype.resolveType = function(node, isRequired) {
-  var $0;
-  if (node != null && $notnull_bool(this.isFactory) && $notnull_bool(isRequired)) {
-    if ((node instanceof GenericTypeReference)) {
-      var genericReference = (node && node.is$GenericTypeReference());
-      var baseType = Member.prototype.resolveType.call(this, genericReference.baseType, isRequired);
-      var typeArguments = [];
-      var $list = genericReference.typeArguments;
-      for (var $i = 0;$i < $list.length; $i++) {
-        var ref = $list.$index($i);
-        typeArguments.add$1(this.findTypeVariable(ref, isRequired));
-      }
-      node.type = (($0 = baseType.getOrMakeConcreteType$1(typeArguments)) && $0.is$lang_Type());
-      return node.type;
-    }
-  }
-  return Member.prototype.resolveType.call(this, node, isRequired);
-}
 MethodMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 MethodMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 MethodMember.prototype.canInvoke$2 = function($0, $1) {
   return this.canInvoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$Arguments()));
 };
 MethodMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 };
 MethodMember.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool(isDynamic));
 };
 MethodMember.prototype.invoke$5 = function($0, $1, $2, $3, $4) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), $assert_bool($4));
 };
 MethodMember.prototype.namesInOrder$1 = function($0) {
   return this.namesInOrder(($0 && $0.is$Arguments()));
 };
 MethodMember.prototype.provideFieldSyntax$0 = MethodMember.prototype.provideFieldSyntax;
 MethodMember.prototype.providePropertySyntax$0 = MethodMember.prototype.providePropertySyntax;
-MethodMember.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$lang_Type()));
-};
+MethodMember.prototype.resolve$0 = MethodMember.prototype.resolve;
 // ********** Code for MemberSet **************
 function MemberSet(member, isVar) {
   this.name = member.name;
   this.members = [member];
   this.jsname = member.get$jsname();
   this.isVar = isVar;
   // Initializers done
 }
 MemberSet.prototype.is$MemberSet = function(){return this;};
 MemberSet.prototype.get$name = function() { return this.name; };
@@ skipping 61 matching lines @@
   var returnValue;
   var targets = this.members.filter((function (m) {
     return m.get$canGet();
   })
   );
   if ($notnull_bool(this.isVar)) {
     targets.forEach$1((function (m) {
       return m._get(context, node, target, true);
     })
     );
-    returnValue = new Value(this._foldTypes((targets && targets.is$List$Member())), null, node.span, true);
+    returnValue = new Value(this._foldTypes((targets && targets.is$List_Member())), null, node.span, true);
   }
   else {
     if (this.members.length == 1) {
       return this.members.$index(0)._get(context, node, target, isDynamic);
     }
     else if ($notnull_bool($eq(targets.length, 1))) {
       return targets.$index(0)._get(context, node, target, isDynamic);
     }
     for (var $i = targets.iterator$0(); $i.hasNext$0(); ) {
       var member = $i.next$0();
@@ skipping 18 matching lines @@
   var returnValue;
   var targets = this.members.filter((function (m) {
     return m.get$canSet();
   })
   );
   if ($notnull_bool(this.isVar)) {
     targets.forEach$1((function (m) {
       return m._set(context, node, target, value, true);
     })
     );
-    returnValue = new Value(this._foldTypes((targets && targets.is$List$Member())), null, node.span, true);
+    returnValue = new Value(this._foldTypes((targets && targets.is$List_Member())), null, node.span, true);
   }
   else {
     if (this.members.length == 1) {
       return this.members.$index(0)._set(context, node, target, value, isDynamic);
     }
     else if ($notnull_bool($eq(targets.length, 1))) {
       return targets.$index(0)._set(context, node, target, value, isDynamic);
     }
     for (var $i = targets.iterator$0(); $i.hasNext$0(); ) {
       var member = $i.next$0();
@@ skipping 83 matching lines @@
     $globals.world.objectType.varStubs = $map([]);
   }
   var stubName = _getCallStubName(this.name, args);
   var stub = $globals.world.objectType.varStubs.$index(stubName);
   if ($notnull_bool(stub == null)) {
     var mset = context.findMembers(this.name).members;
     var targets = mset.filter((function (m) {
       return m.canInvoke$2(context, args);
     })
     );
-    stub = new VarMethodSet($assert_String(stubName), targets, args, this._foldTypes((targets && targets.is$List$Member())));
+    stub = new VarMethodSet($assert_String(stubName), targets, args, this._foldTypes((targets && targets.is$List_Member())));
     $globals.world.objectType.varStubs.$setindex(stubName, stub);
   }
   return (stub && stub.is$VarMember());
 }
 MemberSet.prototype._foldTypes = function(targets) {
   var $0;
   return (($0 = reduce(map(targets, (function (t) {
     return t.get$returnType();
   })
   ), lang_Type.union, $globals.world.varType)) && $0.is$lang_Type());
@@ skipping 24 matching lines @@
 function FactoryMap() {
   this.factories = $map([]);
   // Initializers done
 }
 FactoryMap.prototype.getFactoriesFor = function(typeName) {
   var ret = this.factories.$index(typeName);
   if ($notnull_bool(ret == null)) {
     ret = $map([]);
     this.factories.$setindex(typeName, ret);
   }
-  return (ret && ret.is$Map$String$Member());
+  return (ret && ret.is$Map_String$Member());
 }
 FactoryMap.prototype.addFactory = function(typeName, name, member) {
   this.getFactoriesFor(typeName).$setindex(name, member);
 }
 FactoryMap.prototype.getFactory = function(typeName, name) {
   var $0;
   return (($0 = this.getFactoriesFor(typeName).$index(name)) && $0.is$Member());
 }
 FactoryMap.prototype.forEach = function(f) {
   this.factories.forEach((function (_, constructors) {
@@ skipping 59 matching lines @@
 SourceFile.prototype.get$lineStarts = function() {
   if (this._lineStarts == null) {
     var starts = [0];
     var index = 0;
     while (index < this.get$text().length) {
       index = this.get$text().indexOf('\n', $assert_num(index)) + 1;
       if (index <= 0) break;
       starts.add$1(index);
     }
     starts.add$1(this.get$text().length + 1);
-    this._lineStarts = (starts && starts.is$List$int());
+    this._lineStarts = (starts && starts.is$List_int());
   }
   return this._lineStarts;
 }
 SourceFile.prototype.getLine = function(position) {
   var starts = this.get$lineStarts();
   for (var i = 0;
    i < $assert_num(starts.length); i++) {
     if (starts.$index(i) > position) return i - 1;
   }
   $globals.world.internalError('bad position');
@@ skipping 1911 matching lines @@
 }
 lang_Parser.prototype.compilationUnit = function() {
   var ret = [];
   this._maybeEat(13/*TokenKind.HASHBANG*/);
   while ($notnull_bool(this._peekKind(12/*TokenKind.HASH*/))) {
     ret.add$1(this.directive());
   }
   while (!$notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/))) {
     ret.add$1(this.topLevelDefinition());
   }
-  return (ret && ret.is$List$Definition());
+  return (ret && ret.is$List_Definition());
 }
 lang_Parser.prototype.directive = function() {
   var start = this._peekToken.start;
   this._eat(12/*TokenKind.HASH*/);
   var name = this.identifier();
   var args = this.arguments();
   this._eatSemicolon();
   return new DirectiveDefinition(name, args, this._makeSpan(start));
 }
 lang_Parser.prototype.topLevelDefinition = function() {
@@ skipping 56 matching lines @@
 lang_Parser.prototype.functionTypeAlias = function() {
   var start = this._peekToken.start;
   this._eat(87/*TokenKind.TYPEDEF*/);
   var di = this.declaredIdentifier(false);
   var typeParams = null;
   if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     typeParams = this.typeParameters();
   }
   var formals = this.formalParameterList();
   this._eatSemicolon();
-  var func = new FunctionDefinition(null, di.get$type(), di.get$name(), formals, null, null, this._makeSpan(start));
+  var func = new FunctionDefinition(null, di.get$type(), di.get$name(), formals, null, null, null, this._makeSpan(start));
   return new FunctionTypeDefinition(func, typeParams, this._makeSpan(start));
 }
 lang_Parser.prototype.initializers = function() {
   this._inInitializers = true;
   var ret = [];
   do {
     ret.add$1(this.expression());
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   this._inInitializers = false;
@@ skipping 30 matching lines @@
         this._eatSemicolon();
         return new NativeStatement(nativeBody, this._makeSpan(start));
       }
       else {
         return this.functionBody(inExpression);
       }
     }
   }
   this._lang_error('Expected function body (neither { nor => found)');
 }
-lang_Parser.prototype.finishField = function(start, modifiers, type, name, value) {
+lang_Parser.prototype.finishField = function(start, modifiers, typeParams, type, name, value) {
+  if (typeParams != null) {
+    $globals.world.internalError('trying to create a generic field', this._makeSpan($assert_num(start)));
+  }
   var names = [name];
   var values = [value];
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
     names.add$1(this.identifier());
     if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       values.add$1(this.expression());
     }
     else {
       values.add$1();
     }
   }
   this._eatSemicolon();
   return new VariableDefinition(modifiers, type, names, values, this._makeSpan($assert_num(start)));
 }
-lang_Parser.prototype.finishDefinition = function(start, modifiers, di) {
+lang_Parser.prototype.finishDefinition = function(start, modifiers, di, typeParams) {
   var $0;
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       var formals = this.formalParameterList();
       var inits = null;
       if ($notnull_bool(this._maybeEat(8/*TokenKind.COLON*/))) {
         inits = this.initializers();
       }
       var body = this.functionBody(false);
       if ($notnull_bool(di.get$name() == null)) {
         di.set$name(di.get$type().get$name());
       }
-      return new FunctionDefinition(modifiers, di.get$type(), di.get$name(), formals, inits, body, this._makeSpan($assert_num(start)));
+      return new FunctionDefinition(modifiers, di.get$type(), di.get$name(), formals, typeParams, inits, body, this._makeSpan(start));
 
     case 20/*TokenKind.ASSIGN*/:
 
       this._eat(20/*TokenKind.ASSIGN*/);
       var value = this.expression();
-      return this.finishField(start, modifiers, di.get$type(), di.get$name(), value);
+      return this.finishField(start, modifiers, typeParams, di.get$type(), di.get$name(), value);
 
     case 11/*TokenKind.COMMA*/:
     case 10/*TokenKind.SEMICOLON*/:
 
-      return this.finishField(start, modifiers, di.get$type(), di.get$name(), null);
+      return this.finishField(start, modifiers, typeParams, di.get$type(), di.get$name(), null);
 
     default:
 
       this._errorExpected('declaration');
       return null;
 
   }
 }
 lang_Parser.prototype.declaration = function(includeOperators) {
   var start = this._peekToken.start;
   if ($notnull_bool(this._peekKind(75/*TokenKind.FACTORY*/))) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
-  return this.finishDefinition(start, modifiers, this.declaredIdentifier(includeOperators));
+  return this.finishDefinition(start, (modifiers && modifiers.is$List_Token()), this.declaredIdentifier(includeOperators), null);
 }
 lang_Parser.prototype.factoryConstructorDeclaration = function() {
   var $0;
   var start = this._peekToken.start;
   var factoryToken = this._lang_next();
   var names = [this.identifier()];
   while ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     names.add$1(this.identifier());
   }
   var typeParams = null;
@@ skipping 14 matching lines @@
     }
   }
   else {
     name = new lang_Identifier('', (($0 = names.$index(0).get$span()) && $0.is$SourceSpan()));
   }
   if (names.length > 1) {
     this._lang_error('unsupported qualified name for factory', (($0 = names.$index(0).get$span()) && $0.is$SourceSpan()));
   }
   type = new NameTypeReference(false, names.$index(0), null, (($0 = names.$index(0).get$span()) && $0.is$SourceSpan()));
   var di = new DeclaredIdentifier(type, name, this._makeSpan(start));
-  return this.finishDefinition(start, [factoryToken], di);
+  return this.finishDefinition(start, [factoryToken], di, (typeParams && typeParams.is$List_ParameterType()));
 }
 lang_Parser.prototype.statement = function() {
   var $0;
   switch (this._peek()) {
     case 88/*TokenKind.BREAK*/:
 
       return (($0 = this.breakStatement()) && $0.is$lang_Statement());
 
     case 92/*TokenKind.CONTINUE*/:
 
@@ skipping 69 matching lines @@
       this._eatSemicolon();
       expr.get$func().set$span(this._makeSpan(start));
     }
     return expr.get$func();
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     var value = null;
     if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       value = this.expression();
     }
-    return this.finishField(start, null, expr.get$type(), expr.get$name(), value);
+    return this.finishField(start, null, null, expr.get$type(), expr.get$name(), value);
   }
   else if ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/)) && ((expr.get$x() instanceof DeclaredIdentifier))) {
     var di = (($0 = expr.get$x()) && $0.is$DeclaredIdentifier());
-    return this.finishField(start, null, di.type, di.name, expr.get$y());
+    return this.finishField(start, null, null, di.type, di.name, expr.get$y());
   }
   else if ($notnull_bool(this._isBin(expr, 52/*TokenKind.LT*/)) && $notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
     var baseType = this._makeType(expr.get$x());
     var typeArgs = [this._makeType(expr.get$y())];
     var gt = this._finishTypeArguments((baseType && baseType.is$TypeReference()), 0, typeArgs);
     var name = this.identifier();
     var value = null;
     if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       value = this.expression();
     }
-    return this.finishField(expr.get$span().get$start(), null, gt, name, value);
+    return this.finishField(expr.get$span().get$start(), null, null, gt, name, value);
   }
   else {
     this._eatSemicolon();
     return new lang_ExpressionStatement(expr, this._makeSpan($assert_num(expr.get$span().get$start())));
   }
 }
 lang_Parser.prototype.testCondition = function() {
   this._eatLeftParen();
   var ret = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
@@ skipping 248 matching lines @@
 }
 lang_Parser.prototype.infixExpression = function(precedence) {
   var $0;
   return this.finishInfixExpression((($0 = this.unaryExpression()) && $0.is$lang_Expression()), precedence);
 }
 lang_Parser.prototype._finishDeclaredId = function(type) {
   var name = this.identifier();
   return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan($assert_num(type.get$span().get$start()))));
 }
 lang_Parser.prototype._fixAsType = function(x) {
-  $assert(this._isBin(x, 52/*TokenKind.LT*/), "_isBin(x, TokenKind.LT)", "parser.dart", 803, 12);
+  $assert(this._isBin(x, 52/*TokenKind.LT*/), "_isBin(x, TokenKind.LT)", "parser.dart", 805, 12);
   if ($notnull_bool(this._maybeEat(53/*TokenKind.GT*/))) {
     var base = this._makeType(x.x);
     var typeParam = this._makeType(x.y);
     var type = new GenericTypeReference(base, [typeParam], 0, this._makeSpan(x.span.start));
     return this._finishDeclaredId(type);
   }
   else {
-    $assert(this._peekKind(52/*TokenKind.LT*/), "_peekKind(TokenKind.LT)", "parser.dart", 814, 14);
+    $assert(this._peekKind(52/*TokenKind.LT*/), "_peekKind(TokenKind.LT)", "parser.dart", 816, 14);
     var base = this._makeType(x.x);
     var paramBase = this._makeType(x.y);
     var firstParam = this.addTypeArguments((paramBase && paramBase.is$TypeReference()), 1);
     var type;
     if (firstParam.get$depth() <= 0) {
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     else if ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       type = this._finishTypeArguments((base && base.is$TypeReference()), 0, [firstParam]);
     }
@@ skipping 333 matching lines @@
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
 lang_Parser.prototype._parenOrLambda = function() {
   var $0;
   var start = this._peekToken.start;
   if ($notnull_bool(this._atClosureParameters())) {
     var formals = this.formalParameterList();
     var body = this.functionBody(true);
-    var func = new FunctionDefinition(null, null, null, formals, null, body, this._makeSpan(start));
+    var func = new FunctionDefinition(null, null, null, formals, null, null, body, this._makeSpan(start));
     return new LambdaExpression(func, (($0 = func.get$span()) && $0.is$SourceSpan()));
   }
   else {
     var saved = this._inInitializers;
     this._inInitializers = false;
     var args = this.arguments();
     this._inInitializers = $assert_bool(saved);
     if ($notnull_bool($eq(args.length, 1))) {
       return new ParenExpression(args.$index(0).get$value(), this._makeSpan(start));
     }
@@ skipping 13 matching lines @@
   this._afterParensIndex++;
 }
 lang_Parser.prototype._peekAfterCloseParen = function() {
   var $0;
   if (this._afterParensIndex < this._afterParens.length) {
     return (($0 = this._afterParens.$index(this._afterParensIndex)) && $0.is$lang_Token());
   }
   this._afterParensIndex = 0;
   this._afterParens.clear();
   var tokens = [this._lang_next()];
-  this._lookaheadAfterParens((tokens && tokens.is$List$Token()));
+  this._lookaheadAfterParens((tokens && tokens.is$List_Token()));
   var after = this._peekToken;
   tokens.add$1(after);
   this.tokenizer = new DivertedTokenSource(tokens, this, this.tokenizer);
   this._lang_next();
   return (after && after.is$lang_Token());
 }
 lang_Parser.prototype._lookaheadAfterParens = function(tokens) {
   var saved = this._afterParens.length;
   this._afterParens.add(null);
   while (true) {
@@ skipping 114 matching lines @@
   }
   else {
     return -1;
   }
 }
 lang_Parser.parseHex = function(hex) {
   var result = 0;
   for (var i = 0;
    i < hex.length; i++) {
     var digit = lang_Parser._hexDigit(hex.charCodeAt(i));
-    $assert($ne(digit, -1), "digit != -1", "parser.dart", 1343, 14);
+    $assert($ne(digit, -1), "digit != -1", "parser.dart", 1345, 14);
     result = (result << 4) + $assert_num(digit);
   }
   return $assert_num(result);
 }
 lang_Parser.prototype.finishNewExpression = function(start, isConst) {
   var type = this.type(0);
   var name = null;
   if ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     name = this.identifier();
   }
@@ skipping 67 matching lines @@
   }
   return null;
 }
 lang_Parser.prototype.typeParameter = function() {
   var start = this._peekToken.start;
   var name = this.identifier();
   var myType = null;
   if ($notnull_bool(this._maybeEat(74/*TokenKind.EXTENDS*/))) {
     myType = this.type(1);
   }
-  return new TypeParameter(name, myType, this._makeSpan(start));
+  var tp = new TypeParameter(name, myType, this._makeSpan(start));
+  return new ParameterType($assert_String(name.get$name()), tp);
+}
+lang_Parser.prototype.get$typeParameter = function() {
+  return lang_Parser.prototype.typeParameter.bind(this);
 }
 lang_Parser.prototype.typeParameters = function() {
   this._eat(52/*TokenKind.LT*/);
   var closed = false;
   var ret = [];
   do {
     var tp = this.typeParameter();
     ret.add$1(tp);
-    if ((tp.get$extendsType() instanceof GenericTypeReference) && $notnull_bool($eq(tp.get$extendsType().get$depth(), 0))) {
+    if ((tp.get$typeParameter().get$extendsType() instanceof GenericTypeReference) && $notnull_bool($eq(tp.get$typeParameter().get$extendsType().get$depth(), 0))) {
       closed = true;
       break;
     }
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   if (!$notnull_bool(closed)) {
     this._eat(53/*TokenKind.GT*/);
   }
-  return ret;
+  return (ret && ret.is$List_ParameterType());
 }
 lang_Parser.prototype.get$typeParameters = function() {
   return lang_Parser.prototype.typeParameters.bind(this);
 }
 lang_Parser.prototype._eatClosingAngle = function(depth) {
   if ($notnull_bool(this._maybeEat(53/*TokenKind.GT*/))) {
     return depth;
   }
   else if (depth > 0 && $notnull_bool(this._maybeEat(40/*TokenKind.SAR*/))) {
     return depth - 1;
@@ skipping 91 matching lines @@
   var name = di.get$name();
   var value = null;
   if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
     if (!$notnull_bool(inOptionalBlock)) {
       this._lang_error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
   else if ($notnull_bool(this._peekKind(2/*TokenKind.LPAREN*/))) {
     var formals = this.formalParameterList();
-    var func = new FunctionDefinition(null, type, name, formals, null, null, this._makeSpan(start));
+    var func = new FunctionDefinition(null, type, name, formals, null, null, null, this._makeSpan(start));
     type = new FunctionTypeReference(false, func, (($0 = func.get$span()) && $0.is$SourceSpan()));
   }
   if ($notnull_bool(inOptionalBlock) && $notnull_bool(value == null)) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
 }
 lang_Parser.prototype.formalParameterList = function() {
   this._eatLeftParen();
   var formals = [];
@@ skipping 35 matching lines @@
     type = null;
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     name = expr.get$name();
     type = expr.get$type();
   }
   else {
     this._lang_error('bad function body', (($0 = expr.get$span()) && $0.is$SourceSpan()));
   }
   var span = new SourceSpan(expr.get$span().get$file(), expr.get$span().get$start(), body.get$span().get$end());
-  var func = new FunctionDefinition(null, type, name, formals, null, body, (span && span.is$SourceSpan()));
+  var func = new FunctionDefinition(null, type, name, formals, null, null, body, (span && span.is$SourceSpan()));
   return new LambdaExpression(func, (($0 = func.get$span()) && $0.is$SourceSpan()));
 }
 lang_Parser.prototype._makeDeclaredIdentifier = function(e) {
   var $0;
   if ((e instanceof VarExpression)) {
     return new DeclaredIdentifier(null, e.get$name(), (($0 = e.get$span()) && $0.is$SourceSpan()));
   }
   else if ((e instanceof DeclaredIdentifier)) {
     return e;
   }
@@ skipping 179 matching lines @@
 VariableDefinition.prototype.set$names = function(value) { return this.names = value; };
 VariableDefinition.prototype.get$values = function() { return this.values; };
 VariableDefinition.prototype.set$values = function(value) { return this.values = 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) {
+function FunctionDefinition(modifiers, returnType, name, formals, typeParameters, initializers, body, span) {
   this.modifiers = modifiers;
   this.returnType = returnType;
   this.name = name;
   this.formals = formals;
+  this.typeParameters = typeParameters;
   this.initializers = initializers;
   this.body = body;
   // Initializers done
   Definition.call(this, span);
 }
 $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.get$typeParameters = function() { return this.typeParameters; };
+FunctionDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 FunctionDefinition.prototype.get$initializers = function() { return this.initializers; };
 FunctionDefinition.prototype.set$initializers = function(value) { return this.initializers = value; };
 FunctionDefinition.prototype.get$body = function() { return this.body; };
 FunctionDefinition.prototype.set$body = function(value) { return this.body = value; };
 FunctionDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
 }
 FunctionDefinition.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
@@ skipping 783 matching lines @@
 DeclaredIdentifier.prototype.get$name = function() { return this.name; };
 DeclaredIdentifier.prototype.set$name = function(value) { return this.name = value; };
 DeclaredIdentifier.prototype.visit = function(visitor) {
   return visitor.visitDeclaredIdentifier(this);
 }
 DeclaredIdentifier.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for lang_Type **************
 function lang_Type(name) {
-  this.name = name;
   this.isTested = false;
   this._resolvedMembers = $map([]);
   // Initializers done
+  lang_Element.call(this, name, null);
 }
+$inherits(lang_Type, lang_Element);
 lang_Type.prototype.is$lang_Type = function(){return this;};
-lang_Type.prototype.is$Named = function(){return this;};
-lang_Type.prototype.get$name = function() { return this.name; };
 lang_Type.prototype.get$isTested = function() { return this.isTested; };
 lang_Type.prototype.set$isTested = function(value) { return this.isTested = value; };
 lang_Type.prototype.get$typeCheckCode = function() { return this.typeCheckCode; };
 lang_Type.prototype.set$typeCheckCode = function(value) { return this.typeCheckCode = value; };
 lang_Type.prototype.get$varStubs = function() { return this.varStubs; };
 lang_Type.prototype.set$varStubs = function(value) { return this.varStubs = value; };
 lang_Type.prototype.markUsed = function() {
 
 }
 lang_Type.prototype.get$typeMember = function() {
@@ skipping 50 matching lines @@
 }
 lang_Type.prototype.get$isClosed = function() {
   return $notnull_bool(this.get$isString()) || $notnull_bool(this.get$isBool()) || $notnull_bool(this.get$isNum()) || $notnull_bool(this.get$isFunction()) || $notnull_bool(this.get$isVar());
 }
 lang_Type.prototype.get$isUsed = function() {
   return false;
 }
 lang_Type.prototype.get$isGeneric = function() {
   return false;
 }
-lang_Type.prototype.get$isNativeType = function() {
-  return false;
-}
-lang_Type.prototype.get$isNative = function() {
-  return this.get$isNativeType();
-}
 lang_Type.prototype.get$isHiddenNativeType = function() {
   return false;
 }
 lang_Type.prototype.get$hasTypeParams = function() {
   return false;
 }
 lang_Type.prototype.get$typeofName = function() {
   return null;
 }
-lang_Type.prototype.get$jsname = function() {
-  return this._jsname == null ? this.name : this._jsname;
-}
-lang_Type.prototype.set$jsname = function(name) {
-  return this._jsname = name;
-}
 lang_Type.prototype.get$members = function() {
   return null;
 }
 lang_Type.prototype.get$definition = function() {
   return null;
 }
 lang_Type.prototype.get$factories = function() {
   return null;
 }
 lang_Type.prototype.get$typeArgsInOrder = function() {
   return null;
 }
 lang_Type.prototype.get$genericType = function() {
   return (this && this.is$DefinedType());
 }
 lang_Type.prototype.get$interfaces = function() {
   return null;
 }
 lang_Type.prototype.get$parent = function() {
   return null;
 }
 lang_Type.prototype.getAllMembers = function() {
   return $map([]);
 }
-lang_Type.prototype.hashCode = function() {
-  return this.name.hashCode();
-}
 lang_Type.prototype.get$hasNativeSubtypes = function() {
   if (this._hasNativeSubtypes == null) {
     this._hasNativeSubtypes = this.get$subtypes().some((function (t) {
-      return t.get$isNativeType();
+      return t.get$isNative();
     })
     );
   }
   return this._hasNativeSubtypes;
 }
 lang_Type.prototype._checkOverride = function(member) {
   var parentMember = this._getMemberInParents(member.name);
   if ($notnull_bool($ne(parentMember, null))) {
     if (!$notnull_bool(member.get$isPrivate()) || $eq(member.get$library(), parentMember.get$library())) {
       member.override((parentMember && parentMember.is$Member()));
@@ skipping 182 matching lines @@
 lang_Type.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
 lang_Type.prototype.getFactory$2 = function($0, $1) {
   return this.getFactory(($0 && $0.is$lang_Type()), $assert_String($1));
 };
 lang_Type.prototype.getMember$1 = function($0) {
   return this.getMember($assert_String($0));
 };
 lang_Type.prototype.getOrMakeConcreteType$1 = function($0) {
-  return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
+  return this.getOrMakeConcreteType(($0 && $0.is$List_Type()));
 };
-lang_Type.prototype.hashCode$0 = lang_Type.prototype.hashCode;
 lang_Type.prototype.isAssignable$1 = function($0) {
   return this.isAssignable(($0 && $0.is$lang_Type()));
 };
 lang_Type.prototype.isSubtypeOf$1 = function($0) {
   return this.isSubtypeOf(($0 && $0.is$lang_Type()));
 };
 lang_Type.prototype.markUsed$0 = lang_Type.prototype.markUsed;
 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);
 }
 $inherits(ParameterType, lang_Type);
 ParameterType.prototype.is$ParameterType = function(){return this;};
+ParameterType.prototype.get$typeParameter = function() { return this.typeParameter; };
+ParameterType.prototype.set$typeParameter = function(value) { return this.typeParameter = value; };
 ParameterType.prototype.get$extendsType = function() { return this.extendsType; };
 ParameterType.prototype.set$extendsType = function(value) { return this.extendsType = value; };
 ParameterType.prototype.get$isClass = function() {
   return false;
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
 ParameterType.prototype.get$span = function() {
   return this.typeParameter.span;
@@ skipping 19 matching lines @@
 ParameterType.prototype.getOrMakeConcreteType = function(typeArgs) {
   $globals.world.internalError('no concrete types of type parameters yet', this.get$span());
 }
 ParameterType.prototype.resolveTypeParams = function(inType) {
   var $0;
   return (($0 = inType.typeArguments.$index(this.name)) && $0.is$lang_Type());
 }
 ParameterType.prototype.addDirectSubtype = function(type) {
   $globals.world.internalError('no subtypes of type parameters yet', this.get$span());
 }
-ParameterType.prototype.resolve = function(inType) {
+ParameterType.prototype.resolve = function() {
   if (this.typeParameter.extendsType != null) {
-    this.extendsType = inType.resolveType(this.typeParameter.extendsType, true);
+    this.extendsType = this.get$enclosingElement().resolveType(this.typeParameter.extendsType, true);
   }
   else {
     this.extendsType = $globals.world.objectType;
   }
 }
 ParameterType.prototype.addDirectSubtype$1 = function($0) {
   return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 ParameterType.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
 ParameterType.prototype.getOrMakeConcreteType$1 = function($0) {
-  return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
+  return this.getOrMakeConcreteType(($0 && $0.is$List_Type()));
 };
 ParameterType.prototype.isSubtypeOf$1 = function($0) {
   return this.isSubtypeOf(($0 && $0.is$lang_Type()));
 };
-ParameterType.prototype.resolve$1 = function($0) {
-  return this.resolve(($0 && $0.is$lang_Type()));
-};
+ParameterType.prototype.resolve$0 = ParameterType.prototype.resolve;
 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
@@ skipping 65 matching lines @@
 }
 NonNullableType.prototype.get$hasTypeParams = function() {
   return this.type.get$hasTypeParams();
 }
 NonNullableType.prototype.get$typeofName = function() {
   return this.type.get$typeofName();
 }
 NonNullableType.prototype.get$jsname = function() {
   return this.type.get$jsname();
 }
-NonNullableType.prototype.set$jsname = function(name) {
-  return this.type.set$jsname(name);
-}
 NonNullableType.prototype.get$members = function() {
   return this.type.get$members();
 }
 NonNullableType.prototype.get$definition = function() {
   return this.type.get$definition();
 }
 NonNullableType.prototype.get$factories = function() {
   return this.type.get$factories();
 }
 NonNullableType.prototype.get$typeArgsInOrder = function() {
   var $0;
-  return (($0 = this.type.get$typeArgsInOrder()) && $0.is$Collection$Type());
+  return (($0 = this.type.get$typeArgsInOrder()) && $0.is$Collection_Type());
 }
 NonNullableType.prototype.get$genericType = function() {
   return this.type.get$genericType();
 }
 NonNullableType.prototype.get$interfaces = function() {
   return this.type.get$interfaces();
 }
 NonNullableType.prototype.get$parent = function() {
   return this.type.get$parent();
 }
 NonNullableType.prototype.getAllMembers = function() {
   return this.type.getAllMembers();
 }
-NonNullableType.prototype.get$isNativeType = function() {
-  return this.type.get$isNativeType();
+NonNullableType.prototype.get$isNative = function() {
+  return this.type.get$isNative();
 }
 NonNullableType.prototype.addDirectSubtype$1 = function($0) {
   return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 NonNullableType.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
 NonNullableType.prototype.getFactory$2 = function($0, $1) {
   return this.getFactory(($0 && $0.is$lang_Type()), $assert_String($1));
 };
 NonNullableType.prototype.getMember$1 = function($0) {
   return this.getMember($assert_String($0));
 };
 NonNullableType.prototype.getOrMakeConcreteType$1 = function($0) {
-  return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
+  return this.getOrMakeConcreteType(($0 && $0.is$List_Type()));
 };
 NonNullableType.prototype.isSubtypeOf$1 = function($0) {
   return this.isSubtypeOf(($0 && $0.is$lang_Type()));
 };
 NonNullableType.prototype.markUsed$0 = NonNullableType.prototype.markUsed;
 NonNullableType.prototype.resolveMember$1 = function($0) {
   return this.resolveMember($assert_String($0));
 };
 NonNullableType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
@@ skipping 42 matching lines @@
   var newTypeArgs = [];
   var needsNewType = false;
   var $list = this.typeArgsInOrder;
   for (var $i = 0;$i < $list.length; $i++) {
     var t = $list.$index($i);
     var newType = t.resolveTypeParams$1(inType);
     if ($notnull_bool($ne(newType, t))) needsNewType = true;
     newTypeArgs.add$1(newType);
   }
   if (!$notnull_bool(needsNewType)) return this;
-  return this.genericType.getOrMakeConcreteType((newTypeArgs && newTypeArgs.is$List$Type()));
+  return this.genericType.getOrMakeConcreteType((newTypeArgs && newTypeArgs.is$List_Type()));
 }
 ConcreteType.prototype.getOrMakeConcreteType = function(typeArgs) {
   return this.genericType.getOrMakeConcreteType(typeArgs);
 }
 ConcreteType.prototype.get$parent = function() {
   if (this._parent == null && this.genericType.get$parent() != null) {
     this._parent = this.genericType.get$parent().resolveTypeParams(this);
   }
   return this._parent;
 }
@@ skipping 25 matching lines @@
 ConcreteType.prototype.getAllMembers = function() {
   var result = this.genericType.getAllMembers();
   var $list = result.getKeys$0();
   for (var $i = result.getKeys$0().iterator$0(); $i.hasNext$0(); ) {
     var memberName = $i.next$0();
     var myMember = this.members.$index(memberName);
     if ($notnull_bool($ne(myMember, null))) {
       result.$setindex(memberName, myMember);
     }
   }
-  return (result && result.is$Map$String$Member());
+  return (result && result.is$Map_String$Member());
 }
 ConcreteType.prototype.markUsed = function() {
   this.genericType.markUsed();
 }
 ConcreteType.prototype.genMethod = function(method) {
   this.genericType.genMethod(method);
 }
 ConcreteType.prototype.getFactory = function(type, constructorName) {
   return this.genericType.getFactory(type, constructorName);
 }
@@ skipping 49 matching lines @@
 ConcreteType.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
 ConcreteType.prototype.getFactory$2 = function($0, $1) {
   return this.getFactory(($0 && $0.is$lang_Type()), $assert_String($1));
 };
 ConcreteType.prototype.getMember$1 = function($0) {
   return this.getMember($assert_String($0));
 };
 ConcreteType.prototype.getOrMakeConcreteType$1 = function($0) {
-  return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
+  return this.getOrMakeConcreteType(($0 && $0.is$List_Type()));
 };
 ConcreteType.prototype.markUsed$0 = ConcreteType.prototype.markUsed;
 ConcreteType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 // ********** Code for DefinedType **************
 function DefinedType(name, library, definition, isClass) {
   this.isUsed = false
-  this.isNativeType = false
+  this.isNative = false
   this.library = library;
   this.isClass = isClass;
   this.directSubtypes = new HashSetImplementation();
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
   // Initializers done
   lang_Type.call(this, name);
   this.setDefinition(definition);
 }
@@ skipping 14 matching lines @@
 DefinedType.prototype.get$typeParameters = function() { return this.typeParameters; };
 DefinedType.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 DefinedType.prototype.get$constructors = function() { return this.constructors; };
 DefinedType.prototype.set$constructors = function(value) { return this.constructors = value; };
 DefinedType.prototype.get$members = function() { return this.members; };
 DefinedType.prototype.set$members = function(value) { return this.members = value; };
 DefinedType.prototype.get$factories = function() { return this.factories; };
 DefinedType.prototype.set$factories = function(value) { return this.factories = value; };
 DefinedType.prototype.get$isUsed = function() { return this.isUsed; };
 DefinedType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
-DefinedType.prototype.get$isNativeType = function() { return this.isNativeType; };
-DefinedType.prototype.set$isNativeType = function(value) { return this.isNativeType = value; };
+DefinedType.prototype.get$isNative = function() { return this.isNative; };
+DefinedType.prototype.set$isNative = function(value) { return this.isNative = value; };
 DefinedType.prototype.setDefinition = function(def) {
-  $assert(this.definition == null, "definition == null", "type.dart", 743, 12);
+  var $0;
+  $assert(this.definition == null, "definition == null", "type.dart", 725, 12);
   this.definition = def;
   if ((this.definition instanceof TypeDefinition) && $notnull_bool($ne(this.definition.get$nativeType(), null))) {
-    this.isNativeType = true;
+    this.isNative = true;
   }
-  if (this.definition != null && this.definition.get$typeParameters() != null) {
+  if (this.definition != null && $notnull_bool($ne(this.definition.get$typeParameters(), null))) {
     this._concreteTypes = $map([]);
-    this.typeParameters = [];
-    var $list = this.definition.get$typeParameters();
-    for (var $i = 0;$i < $list.length; $i++) {
-      var tp = $list.$index($i);
-      var paramName = tp.get$name().get$name();
-      this.typeParameters.add(new ParameterType($assert_String(paramName), tp));
-    }
+    this.typeParameters = (($0 = this.definition.get$typeParameters()) && $0.is$List_ParameterType());
   }
 }
 DefinedType.prototype.get$isHiddenNativeType = function() {
   return $eq(this.library, $globals.world.get$dom()) || ($notnull_bool($ne(this.definition.get$nativeType(), null)) && $notnull_bool(this.definition.get$nativeType().get$isConstructorHidden()));
 }
 DefinedType.prototype.get$typeArgsInOrder = function() {
   if (this.typeParameters == null) return null;
   if (this._typeArgsInOrder == null) {
-    this._typeArgsInOrder = new FixedCollection$Type($globals.world.varType, this.typeParameters.length);
+    this._typeArgsInOrder = new FixedCollection_lang_Type($globals.world.varType, this.typeParameters.length);
   }
   return this._typeArgsInOrder;
 }
 DefinedType.prototype.get$isVar = function() {
   return $eq(this, $globals.world.varType);
 }
 DefinedType.prototype.get$isVoid = function() {
   return $eq(this, $globals.world.voidType);
 }
 DefinedType.prototype.get$isTop = function() {
@@ skipping 67 matching lines @@
   var interfaces = [];
   for (var $i = 0;$i < types.length; $i++) {
     var type = types.$index($i);
     var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
     if ($notnull_bool(resolvedInterface.get$isClosed()) && !($notnull_bool(this.library.get$isCore()) || $notnull_bool(this.library.get$isCoreImpl()))) {
       $globals.world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', (($0 = type.get$span()) && $0.is$SourceSpan()));
     }
     resolvedInterface.addDirectSubtype$1(this);
     interfaces.add$1(resolvedInterface);
   }
-  return (interfaces && interfaces.is$List$Type());
+  return (interfaces && interfaces.is$List_Type());
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
-  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 864, 12);
+  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 841, 12);
   this.directSubtypes.add(type);
 }
 DefinedType.prototype.get$subtypes = function() {
   var $0;
   if (this._subtypes == null) {
     this._subtypes = new HashSetImplementation();
     var $list = this.directSubtypes;
     for (var $i = this.directSubtypes.iterator(); $i.hasNext$0(); ) {
       var st = $i.next$0();
       this._subtypes.add(st);
-      this._subtypes.addAll((($0 = st.get$subtypes()) && $0.is$Collection$E()));
+      this._subtypes.addAll((($0 = st.get$subtypes()) && $0.is$Collection_E()));
     }
   }
   return this._subtypes;
 }
 DefinedType.prototype._cycleInClassExtends = function() {
   var seen = new HashSetImplementation();
   seen.add(this);
   var ancestor = this.get$parent();
   while ($notnull_bool($ne(ancestor, null))) {
     if (ancestor === this) {
@@ skipping 27 matching lines @@
     }
     return false;
   }
   for (var i = 0;
    i < this.interfaces.length; i++) {
     if ($notnull_bool(_helper(this.interfaces.$index(i)))) return i;
   }
   return -1;
 }
 DefinedType.prototype.resolve = function() {
-  var $this = this; // closure support
   var $0;
   if ((this.definition instanceof TypeDefinition)) {
     var typeDef = (($0 = this.definition) && $0.is$TypeDefinition());
     if ($notnull_bool(this.isClass)) {
       if (typeDef.extendsTypes != null && typeDef.extendsTypes.length > 0) {
         if (typeDef.extendsTypes.length > 1) {
           $globals.world.error('more than one base class', (($0 = typeDef.extendsTypes.$index(1).get$span()) && $0.is$SourceSpan()));
         }
         var extendsTypeRef = typeDef.extendsTypes.$index(0);
         if ((extendsTypeRef instanceof GenericTypeReference)) {
@@ skipping 37 matching lines @@
       }
     }
   }
   else if ((this.definition instanceof FunctionTypeDefinition)) {
     this.interfaces = [$globals.world.functionType];
   }
   if (this.typeParameters != null) {
     var $list = this.typeParameters;
     for (var $i = 0;$i < $list.length; $i++) {
       var tp = $list.$index($i);
-      tp.resolve$1(this);
+      tp.set$enclosingElement(this);
+      tp.resolve$0();
     }
   }
   $globals.world._addType(this);
   var $list = this.constructors.getValues();
   for (var $i = this.constructors.getValues().iterator$0(); $i.hasNext$0(); ) {
     var c = $i.next$0();
-    c.resolve$1(this);
+    c.resolve$0();
   }
   var $list0 = this.members.getValues();
   for (var $i = this.members.getValues().iterator$0(); $i.hasNext$0(); ) {
     var m = $i.next$0();
-    m.resolve$1(this);
+    m.resolve$0();
   }
   this.factories.forEach((function (f) {
-    return f.resolve$1($this);
+    return f.resolve$0();
   })
   );
 }
 DefinedType.prototype.addMethod = function(methodName, definition) {
   if (methodName == null) methodName = definition.name.name;
   var method = new MethodMember(methodName, this, definition);
   if ($notnull_bool(method.get$isConstructor())) {
     if (this.constructors.containsKey(method.get$constructorName())) {
       $globals.world.error(('duplicate constructor definition of ' + method.get$name()), definition.span);
       return;
@@ skipping 47 matching lines @@
     if (this.members.containsKey(name)) {
       $globals.world.error(('duplicate field definition of "' + name + '"'), definition.span);
       return;
     }
     var value = null;
     if (definition.values != null) {
       value = definition.values.$index(i);
     }
     var field = new FieldMember($assert_String(name), this, definition, value);
     this.members.$setindex(name, field);
-    if ($notnull_bool(this.isNativeType)) {
+    if ($notnull_bool(this.isNative)) {
       field.set$isNative(true);
     }
   }
 }
 DefinedType.prototype.getFactory = function(type, constructorName) {
   var ret = this.factories.getFactory(type.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.constructors.$index(constructorName);
@@ skipping 10 matching lines @@
   }
   ret = this.factories.getFactory(this.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype._tryCreateDefaultConstructor = function(name) {
   var $0;
   if (name == '' && this.definition != null && $notnull_bool(this.isClass) && this.constructors.get$length() == 0) {
     var span = this.definition.span;
     var inits = null, body = null;
-    if ($notnull_bool(this.isNativeType)) {
+    if ($notnull_bool(this.isNative)) {
       body = new NativeStatement(null, (span && span.is$SourceSpan()));
       inits = null;
     }
     else {
       body = null;
       inits = [new CallExpression(new SuperExpression((span && span.is$SourceSpan())), [], (span && span.is$SourceSpan()))];
     }
     var typeDef = (($0 = this.definition) && $0.is$TypeDefinition());
-    var c = new FunctionDefinition(null, null, typeDef.name, [], inits, body, (span && span.is$SourceSpan()));
+    var c = new FunctionDefinition(null, null, typeDef.name, [], null, inits, body, (span && span.is$SourceSpan()));
     this.addMethod(null, (c && c.is$FunctionDefinition()));
-    this.constructors.$index('').resolve$1(this);
+    this.constructors.$index('').resolve$0();
     return this.constructors.$index('');
   }
   return null;
 }
 DefinedType.prototype.getMember = function(memberName) {
   var $0;
   var member = (($0 = this.members.$index(memberName)) && $0.is$Member());
   if (member != null) {
     this._checkOverride(member);
     return member;
   }
   if ($notnull_bool(this.get$isTop())) {
     var libType = this.library.findTypeByName(memberName);
     if ($notnull_bool($ne(libType, null))) {
       return (($0 = libType.get$typeMember()) && $0.is$Member());
     }
   }
   return this._getMemberInParents(memberName);
 }
-DefinedType._getDottedName = function(type) {
-  if (type.names != null) {
-    var names = map(type.names, (function (n) {
-      return n.get$name();
-    })
-    );
-    return type.name.name + '.' + Strings.join((names && names.is$List$String()), '.');
-  }
-  else {
-    return type.name.name;
-  }
-}
-DefinedType.prototype.resolveType = function(node, typeErrors) {
-  var $0;
-  if (node == null) return $globals.world.varType;
-  if (node.type != null) return node.type;
-  if ((node instanceof NameTypeReference)) {
-    var typeRef = (node && node.is$NameTypeReference());
-    var name;
-    if (typeRef.names != null) {
-      name = $assert_String(typeRef.names.last().get$name());
-    }
-    else {
-      name = typeRef.name.name;
-    }
-    if (this.typeParameters != null) {
-      var $list = this.typeParameters;
-      for (var $i = 0;$i < $list.length; $i++) {
-        var tp = $list.$index($i);
-        if ($notnull_bool($eq(tp.get$name(), name))) {
-          typeRef.type = (tp && tp.is$lang_Type());
-        }
-      }
-    }
-    if (typeRef.type == null) {
-      typeRef.type = this.library.findType(typeRef);
-    }
-    if (typeRef.type == null) {
-      var message = ('cannot find type ' + DefinedType._getDottedName(typeRef));
-      if ($notnull_bool(typeErrors)) {
-        $globals.world.error($assert_String(message), typeRef.span);
-        typeRef.type = $globals.world.objectType;
-      }
-      else {
-        $globals.world.warning($assert_String(message), typeRef.span);
-        typeRef.type = $globals.world.varType;
-      }
-    }
-  }
-  else if ((node instanceof GenericTypeReference)) {
-    var typeRef = (node && node.is$GenericTypeReference());
-    var baseType = this.resolveType(typeRef.baseType, typeErrors);
-    if (!$notnull_bool(baseType.get$isGeneric())) {
-      $globals.world.error(('' + baseType.get$name() + ' is not generic'), typeRef.span);
-      return null;
-    }
-    if (typeRef.typeArguments.length != baseType.get$typeParameters().length) {
-      $globals.world.error('wrong number of type arguments', typeRef.span);
-      return null;
-    }
-    var typeArgs = [];
-    for (var i = 0;
-     i < typeRef.typeArguments.length; i++) {
-      var extendsType = baseType.get$typeParameters().$index(i).get$extendsType();
-      var typeArg = this.resolveType((($0 = typeRef.typeArguments.$index(i)) && $0.is$TypeReference()), typeErrors);
-      typeArgs.add$1(typeArg);
-      if ($notnull_bool($ne(extendsType, null)) && !(typeArg instanceof ParameterType)) {
-        typeArg.ensureSubtypeOf$3(extendsType, typeRef.typeArguments.$index(i).get$span(), typeErrors);
-      }
-    }
-    typeRef.type = (($0 = baseType.getOrMakeConcreteType$1(typeArgs)) && $0.is$lang_Type());
-  }
-  else if ((node instanceof FunctionTypeReference)) {
-    var typeRef = (node && node.is$FunctionTypeReference());
-    var name = '';
-    if (typeRef.func.name != null) name = typeRef.func.name.name;
-    typeRef.type = this.library.getOrAddFunctionType($assert_String(name), typeRef.func, this);
-  }
-  else {
-    $globals.world.internalError('unknown type reference', node.span);
-  }
-  return node.type;
-}
 DefinedType.prototype.resolveTypeParams = function(inType) {
   return this;
 }
 DefinedType.prototype.getOrMakeConcreteType = function(typeArgs) {
-  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1261, 12);
-  var names = [this.name];
+  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1158, 12);
+  var jsnames = [];
+  var names = [];
   var typeMap = $map([]);
   for (var i = 0;
    i < typeArgs.length; i++) {
     var paramName = this.typeParameters.$index(i).get$name();
     typeMap.$setindex(paramName, typeArgs.$index(i));
     names.add$1(typeArgs.$index(i).get$name());
+    jsnames.add$1(typeArgs.$index(i).get$jsname());
   }
-  var concreteName = Strings.join((names && names.is$List$String()), '\$');
-  var ret = this._concreteTypes.$index(concreteName);
+  var jsname = ('' + this.get$jsname() + '_' + Strings.join((jsnames && jsnames.is$List_String()), '\$'));
+  var simpleName = ('' + this.name + '<' + Strings.join((names && names.is$List_String()), ', ') + '>');
+  var key = Strings.join((names && names.is$List_String()), '\$');
+  var ret = this._concreteTypes.$index(key);
   if ($notnull_bool(ret == null)) {
-    ret = new ConcreteType($assert_String(concreteName), this, typeMap, typeArgs);
-    this._concreteTypes.$setindex(concreteName, ret);
+    ret = new ConcreteType($assert_String(simpleName), this, typeMap, typeArgs);
+    ret._jsname = $assert_String(jsname);
+    this._concreteTypes.$setindex(key, ret);
   }
   return (ret && ret.is$lang_Type());
 }
 DefinedType.prototype.getCallStub = function(args) {
-  $assert(this.get$isFunction(), "isFunction", "type.dart", 1281, 12);
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1185, 12);
   var name = _getCallStubName('call', args);
   if (this.varStubs == null) this.varStubs = $map([]);
   var stub = this.varStubs.$index(name);
   if ($notnull_bool(stub == null)) {
     stub = new VarFunctionStub($assert_String(name), args);
     this.varStubs.$setindex(name, stub);
   }
   return (stub && stub.is$VarFunctionStub());
 }
 DefinedType.prototype.addDirectSubtype$1 = function($0) {
   return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 DefinedType.prototype.addMethod$2 = function($0, $1) {
   return this.addMethod($assert_String($0), ($1 && $1.is$FunctionDefinition()));
 };
 DefinedType.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
 DefinedType.prototype.getFactory$2 = function($0, $1) {
   return this.getFactory(($0 && $0.is$lang_Type()), $assert_String($1));
 };
 DefinedType.prototype.getMember$1 = function($0) {
   return this.getMember($assert_String($0));
 };
 DefinedType.prototype.getOrMakeConcreteType$1 = function($0) {
-  return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
+  return this.getOrMakeConcreteType(($0 && $0.is$List_Type()));
 };
 DefinedType.prototype.markUsed$0 = DefinedType.prototype.markUsed;
 DefinedType.prototype.resolve$0 = DefinedType.prototype.resolve;
 DefinedType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 DefinedType.prototype.setDefinition$1 = function($0) {
   return this.setDefinition(($0 && $0.is$Definition()));
 };
 // ********** Code for NativeType **************
@@ skipping 11 matching lines @@
 NativeType.prototype.get$name = function() { return this.name; };
 NativeType.prototype.set$name = function(value) { return this.name = value; };
 NativeType.prototype.get$isConstructorHidden = function() { return this.isConstructorHidden; };
 NativeType.prototype.set$isConstructorHidden = function(value) { return this.isConstructorHidden = value; };
 // ********** Code for FixedCollection **************
 function FixedCollection(value, length) {
   this.value = value;
   this.length = length;
   // Initializers done
 }
-FixedCollection.prototype.is$Collection$E = function(){return this;};
-FixedCollection.prototype.is$Collection$Object = function(){return this;};
-FixedCollection.prototype.is$Collection$Type = function(){return this;};
+FixedCollection.prototype.is$Collection_E = function(){return this;};
+FixedCollection.prototype.is$Collection_Object = function(){return this;};
+FixedCollection.prototype.is$Collection_Type = function(){return this;};
 FixedCollection.prototype.is$Iterable = function(){return this;};
 FixedCollection.prototype.get$value = function() { return this.value; };
 FixedCollection.prototype.iterator = function() {
-  return new FixedIterator$E(this.value, this.length);
+  return new FixedIterator_E(this.value, this.length);
 }
 FixedCollection.prototype.forEach = function(f) {
   Collections.forEach(this, f);
 }
 FixedCollection.prototype.filter = function(f) {
   return Collections.filter(this, new ListFactory(), f);
 }
 FixedCollection.prototype.every = function(f) {
   return Collections.every(this, f);
 }
@@ skipping 10 matching lines @@
   return this.filter(to$call$1($0));
 };
 FixedCollection.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 FixedCollection.prototype.isEmpty$0 = FixedCollection.prototype.isEmpty;
 FixedCollection.prototype.iterator$0 = FixedCollection.prototype.iterator;
 FixedCollection.prototype.some$1 = function($0) {
   return this.some(to$call$1($0));
 };
-// ********** Code for FixedCollection$Type **************
-function FixedCollection$Type(value, length) {
+// ********** Code for FixedCollection_lang_Type **************
+function FixedCollection_lang_Type(value, length) {
   this.value = value;
   this.length = length;
   // Initializers done
 }
-$inherits(FixedCollection$Type, FixedCollection);
-FixedCollection$Type.prototype.is$Collection$E = function(){return this;};
-FixedCollection$Type.prototype.is$Collection$Object = function(){return this;};
-FixedCollection$Type.prototype.is$Collection$Type = function(){return this;};
-FixedCollection$Type.prototype.is$Iterable = function(){return this;};
+$inherits(FixedCollection_lang_Type, FixedCollection);
+FixedCollection_lang_Type.prototype.is$Collection_E = function(){return this;};
+FixedCollection_lang_Type.prototype.is$Collection_Object = function(){return this;};
+FixedCollection_lang_Type.prototype.is$Collection_Type = function(){return this;};
+FixedCollection_lang_Type.prototype.is$Iterable = function(){return this;};
 // ********** Code for FixedIterator **************
 function FixedIterator(value, length) {
   this._index = 0
   this.value = value;
   this.length = length;
   // Initializers done
 }
-FixedIterator.prototype.is$Iterator$T = function(){return this;};
+FixedIterator.prototype.is$Iterator_T = function(){return this;};
 FixedIterator.prototype.get$value = function() { return this.value; };
 FixedIterator.prototype.hasNext = function() {
   return this._index < this.length;
 }
 FixedIterator.prototype.next = function() {
   this._index++;
   return this.value;
 }
 FixedIterator.prototype.hasNext$0 = FixedIterator.prototype.hasNext;
 FixedIterator.prototype.next$0 = FixedIterator.prototype.next;
-// ********** Code for FixedIterator$E **************
-function FixedIterator$E(value, length) {
+// ********** Code for FixedIterator_E **************
+function FixedIterator_E(value, length) {
   this._index = 0
   this.value = value;
   this.length = length;
   // Initializers done
 }
-$inherits(FixedIterator$E, FixedIterator);
-FixedIterator$E.prototype.is$Iterator$T = function(){return this;};
+$inherits(FixedIterator_E, FixedIterator);
+FixedIterator_E.prototype.is$Iterator_T = function(){return this;};
 // ********** Code for Value **************
 function Value(type, code, span, needsTemp) {
   this.isSuper = false
   this.isType = false
   this.isFinal = false
   this.type = type;
   this.code = code;
   this.span = span;
   this.needsTemp = needsTemp;
   // Initializers done
@@ skipping 303 matching lines @@
 }
 Value.prototype.invokeNoSuchMethod = function(context, name, node, args) {
   var $0;
   var pos = '';
   if (args != null) {
     var argsCode = [];
     for (var i = 0;
      i < args.get$length(); i++) {
       argsCode.add$1(args.values.$index(i).get$code());
     }
-    pos = Strings.join((argsCode && argsCode.is$List$String()), ", ");
+    pos = Strings.join((argsCode && argsCode.is$List_String()), ", ");
   }
   var noSuchArgs = [new Value($globals.world.stringType, ('"' + name + '"'), node.span, true), new Value($globals.world.listType, ('[' + pos + ']'), node.span, true)];
   return (($0 = this._resolveMember(context, 'noSuchMethod', node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs))) && $0.is$Value());
 }
 Value.prototype.invokeSpecial = function(name, args, returnType) {
-  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 497, 12);
-  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 498, 12);
+  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 496, 12);
+  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 497, 12);
   var argsString = args.getCode();
   if (name == '\$index' || name == '\$setindex') {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), this.span, true);
   }
   else {
     if (argsString.length > 0) argsString = (', ' + argsString);
     $globals.world.gen.corejs.useOperator(name);
     return new Value(returnType, ('' + name + '(' + this.code + argsString + ')'), this.span, true);
   }
 }
@@ skipping 117 matching lines @@
   this.field = field;
   this.name = name;
   this.exp = exp;
   this.canonicalCode = canonicalCode;
   this.dependencies = [];
   // Initializers done
   Value.call(this, type, code, span, !$notnull_bool(isConst));
   for (var $i = 0;$i < _dependencies.length; $i++) {
     var dep = _dependencies.$index($i);
     this.dependencies.add(dep);
-    this.dependencies.addAll((($0 = dep.get$dependencies()) && $0.is$Collection$E()));
+    this.dependencies.addAll((($0 = dep.get$dependencies()) && $0.is$Collection_E()));
   }
 }
 $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 $0;
   var code = ($notnull_bool(exp.get$isConst()) ? exp.get$canonicalCode() : exp.code);
   var codeWithComment = ('' + code + '/*' + field.get$declaringType().get$name() + '.' + field.get$name() + '*/');
   return new GlobalValue(exp.type, $assert_String(codeWithComment), $assert_bool(field.get$isFinal()), field, null, exp, code, exp.span, (($0 = dependencies.filter$1((function (d) {
     return (d instanceof GlobalValue);
   })
-  )) && $0.is$List$GlobalValue()));
+  )) && $0.is$List_GlobalValue()));
 }
 GlobalValue.GlobalValue$fromConst$factory = function(uniqueId, exp, dependencies) {
   var $0;
   var name = ("const\$" + uniqueId);
   var codeWithComment = ("" + name + "/*" + exp.span.get$text() + "*/");
   return new GlobalValue(exp.type, $assert_String(codeWithComment), true, null, name, exp, name, exp.span, (($0 = dependencies.filter$1((function (d) {
     return (d instanceof GlobalValue);
   })
-  )) && $0.is$List$GlobalValue()));
+  )) && $0.is$List_GlobalValue()));
 }
 GlobalValue.prototype.get$field = function() { return this.field; };
 GlobalValue.prototype.set$field = function(value) { return this.field = value; };
 GlobalValue.prototype.get$name = function() { return this.name; };
 GlobalValue.prototype.set$name = function(value) { return this.name = value; };
 GlobalValue.prototype.get$exp = function() { return this.exp; };
 GlobalValue.prototype.set$exp = function(value) { return this.exp = value; };
 GlobalValue.prototype.get$canonicalCode = function() { return this.canonicalCode; };
 GlobalValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
 GlobalValue.prototype.get$isConst = function() {
@@ skipping 47 matching lines @@
 BareValue.prototype._ensureCode = function() {
   if (this.code != null) return;
   if ($notnull_bool(this.isType)) {
     this.code = this.type.get$jsname();
   }
   else {
     this.code = this.home._makeThisCode();
   }
 }
 BareValue.prototype._tryResolveMember = function(context, name) {
-  $assert($eq(context, this.home), "context == home", "value.dart", 718, 12);
+  $assert($eq(context, this.home), "context == home", "value.dart", 717, 12);
   var member = this.type.resolveMember(name);
   if ($notnull_bool($ne(member, null))) {
     this._ensureCode();
     return member;
   }
   member = this.home.get$library().lookup(name, this.span);
   if ($notnull_bool($ne(member, null))) {
     return member;
   }
   this._ensureCode();
@@ skipping 71 matching lines @@
   var mset = this._members.$index(member.name);
   if ($notnull_bool(mset == null)) {
     mset = new MemberSet(member, true);
     this._members.$setindex(mset.get$name(), mset);
   }
   else {
     mset.get$members().add$1(member);
   }
 }
 World.prototype._addTopName = function(named) {
-  var existing = this._topNames.$index(named.get$name());
+  var existing = this._topNames.$index(named.get$jsname());
   if ($notnull_bool($ne(existing, null))) {
-    this.info(('mangling matching top level name "' + named.get$name() + '" in ') + ('both "' + named.get$library().name + '" and "' + existing.get$library().get$name() + '"'));
+    this.info(('mangling matching top level name "' + named.get$jsname() + '" in ') + ('both "' + named.get$library().get$jsname() + '" and "' + existing.get$library().get$jsname() + '"'));
     if ($notnull_bool(named.get$isNative())) {
       if ($notnull_bool(existing.get$isNative())) {
-        $globals.world.internalError(('conflicting native names "' + named.get$name() + '" ') + ('(already defined in ' + existing.get$span().get$locationText() + ')'), named.get$span());
+        $globals.world.internalError(('conflicting native names "' + named.get$jsname() + '" ') + ('(already defined in ' + existing.get$span().get$locationText() + ')'), named.get$span());
       }
       else {
-        this._topNames.$setindex(named.get$name(), named);
-        this._addJavascriptTopName((existing && existing.is$Named()));
+        this._topNames.$setindex(named.get$jsname(), named);
+        this._addJavascriptTopName((existing && existing.is$lang_Element()));
       }
     }
     else if ($notnull_bool(named.get$library().get$isCore())) {
       if ($notnull_bool(existing.get$library().get$isCore())) {
-        $globals.world.internalError(('conflicting top-level names in core "' + named.get$name() + '" ') + ('(previously defined in ' + existing.get$span().get$locationText() + ')'), named.get$span());
+        $globals.world.internalError(('conflicting top-level names in core "' + named.get$jsname() + '" ') + ('(previously defined in ' + existing.get$span().get$locationText() + ')'), named.get$span());
       }
       else {
-        this._topNames.$setindex(named.get$name(), named);
-        this._addJavascriptTopName((existing && existing.is$Named()));
+        this._topNames.$setindex(named.get$jsname(), named);
+        this._addJavascriptTopName((existing && existing.is$lang_Element()));
       }
     }
     else {
       this._addJavascriptTopName(named);
     }
   }
   else {
-    this._topNames.$setindex(named.get$name(), named);
+    this._topNames.$setindex(named.get$jsname(), named);
   }
 }
 World.prototype._addJavascriptTopName = function(named) {
-  named.set$jsname(('' + named.get$library().get$jsname() + '_' + named.get$name()));
+  named._jsname = ('' + named.get$library().get$jsname() + '_' + named.get$jsname());
   var existing = this._topNames.$index(named.get$jsname());
   if ($notnull_bool($ne(existing, null)) && $notnull_bool($ne(existing, named))) {
     $globals.world.internalError(('name mangling failed for "' + named.get$jsname() + '" ') + ('("' + named.get$jsname() + '" defined also in ' + existing.get$span().get$locationText() + ')'), named.get$span());
   }
   this._topNames.$setindex(named.get$jsname(), named);
 }
 World.prototype._addType = function(type) {
   if (!$notnull_bool(type.get$isTop())) this._addTopName(type);
 }
 World.prototype._addToCoreLib = function(name, isClass) {
@@ skipping 302 matching lines @@
 
       case '--compile-only':
 
         this.compileOnly = true;
         continue loop;
 
       default:
 
         if ($notnull_bool(arg.endsWith$1('.dart'))) {
           this.dartScript = $assert_String(arg);
-          this.childArgs = (($0 = args.getRange(i + 1, args.length - i - 1)) && $0.is$List$String());
+          this.childArgs = (($0 = args.getRange(i + 1, args.length - i - 1)) && $0.is$List_String());
           break loop;
         }
         else if ($notnull_bool(arg.startsWith$1('--out='))) {
           this.outfile = $assert_String(arg.substring$1('--out='.length));
         }
         else if ($notnull_bool(arg.startsWith$1('--libdir='))) {
           this.libDir = $assert_String(arg.substring$1('--libdir='.length));
           passedLibDir = true;
         }
         else {
@@ skipping 339 matching lines @@
    i < args.get$length(); i++) {
     nameBuilder.add('\$').add(args.getName(i));
   }
   return nameBuilder.toString();
 }
 //  ********** Library frog **************
 // ********** Code for top level **************
 function main() {
   var homedir = path.dirname(fs.realpathSync($assert_String(process.argv.$index(1))));
   var argv = ListFactory.ListFactory$from$factory(process.argv);
-  if ($notnull_bool(lang_compile($assert_String(homedir), (argv && argv.is$List$String()), new NodeFileSystem()))) {
+  if ($notnull_bool(lang_compile($assert_String(homedir), (argv && argv.is$List_String()), new NodeFileSystem()))) {
     var code = $globals.world.getGeneratedCode();
     if (!$notnull_bool($globals.options.compileOnly)) {
       process.argv = [argv.$index(0), argv.$index(1)];
       process.argv.addAll($globals.options.childArgs);
       vm.runInNewContext($assert_String(code), createSandbox());
     }
   }
   else {
     process.exit(1);
   }
 }
 // ********** Generic Type Inheritance **************
 /** Implements extends for generic types. */
 function $inheritsMembers(child, parent) {
   child = child.prototype;
   parent = parent.prototype;
   Object.getOwnPropertyNames(parent).forEach(function(name) {
     if (typeof(child[name]) == 'undefined') child[name] = parent[name];
   });
 }
-$inheritsMembers(_DoubleLinkedQueueEntrySentinel$E, DoubleLinkedQueueEntry$E);
-$inheritsMembers(_DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V, DoubleLinkedQueueEntry$KeyValuePair$K$V);
-$inheritsMembers(LinkTail$Dynamic, AbstractLink$Dynamic);
-$inheritsMembers(LinkEntry$Dynamic, AbstractLink$Dynamic);
-$inheritsMembers(LinkEntry$T, AbstractLink$T);
-$inheritsMembers(ArrayBasedScanner$SourceString, AbstractScanner$SourceString);
+$inheritsMembers(_DoubleLinkedQueueEntrySentinel_E, DoubleLinkedQueueEntry_E);
+$inheritsMembers(_DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V, DoubleLinkedQueueEntry_KeyValuePair_K$V);
+$inheritsMembers(LinkTail_T, AbstractLink_T);
+$inheritsMembers(LinkEntry_T, AbstractLink_T);
+$inheritsMembers(ArrayBasedScanner_SourceString, AbstractScanner_SourceString);
 //  ********** Globals **************
 function $static_init(){
   $globals.HTracer__singleton = null;
 }
 var const$0 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 var const$1 = new _DeletedKeySentinel()/*const _DeletedKeySentinel()*/;
 var const$10 = new StringWrapper('Dynamic')/*const SourceString('Dynamic')*/;
 var const$101 = new Keyword("negate", true)/*const Keyword("negate", true)*/;
 var const$103 = new Keyword("operator", true)/*const Keyword("operator", true)*/;
 var const$105 = new Keyword("set", true)/*const Keyword("set", true)*/;
@@ skipping 50 matching lines @@
 var const$25 = new Keyword("break", false)/*const Keyword("break")*/;
 var const$250 = new StringWrapper('le')/*const SourceString('le')*/;
 var const$251 = new StringWrapper('>')/*const SourceString('>')*/;
 var const$252 = new StringWrapper('gt')/*const SourceString('gt')*/;
 var const$253 = new StringWrapper('>=')/*const SourceString('>=')*/;
 var const$254 = new StringWrapper('ge')/*const SourceString('ge')*/;
 var const$255 = new StringWrapper('&&')/*const SourceString('&&')*/;
 var const$256 = new StringWrapper('||')/*const SourceString('||')*/;
 var const$257 = new StringWrapper('!')/*const SourceString('!')*/;
 var const$258 = new ElementKind('variable')/*const ElementKind('variable')*/;
-var const$264 = new MessageKind('cannot return value from void function')/*const MessageKind(
+var const$260 = new MessageKind('cannot return value from void function')/*const MessageKind(
       'cannot return value from void function')*/;
-var const$266 = new MessageKind('#{1} is not assignable to #{2}')/*const MessageKind(
+var const$262 = new MessageKind('#{1} is not assignable to #{2}')/*const MessageKind(
       '#{1} is not assignable to #{2}')*/;
-var const$268 = new MessageKind('value of type #{1} expected')/*const MessageKind(
+var const$264 = new MessageKind('value of type #{1} expected')/*const MessageKind(
       'value of type #{1} expected')*/;
+var const$266 = new StringWrapper('=')/*const SourceString('=')*/;
+var const$267 = new MessageKind('variable cannot be of type void')/*const MessageKind(
+      'variable cannot be of type void')*/;
+var const$269 = new MessageKind('expression does not yield a value')/*const MessageKind(
+      'expression does not yield a value')*/;
 var const$27 = new Keyword("case", false)/*const Keyword("case")*/;
-var const$270 = new StringWrapper('=')/*const SourceString('=')*/;
-var const$271 = new MessageKind('variable cannot be of type void')/*const MessageKind(
-      'variable cannot be of type void')*/;
-var const$273 = new MessageKind('expression does not yield a value')/*const MessageKind(
-      'expression does not yield a value')*/;
-var const$275 = new ExceptionImplementation("Internal Error (Leg): UNREACHABLE")/*const Exception("Internal Error (Leg): UNREACHABLE")*/;
-var const$280 = new StringWrapper("&&")/*const SourceString("&&")*/;
-var const$281 = new StringWrapper("||")/*const SourceString("||")*/;
-var const$282 = new StringWrapper("!")/*const SourceString("!")*/;
-var const$283 = new StringWrapper("+")/*const SourceString("+")*/;
-var const$284 = new StringWrapper("-")/*const SourceString("-")*/;
-var const$285 = new StringWrapper("*")/*const SourceString("*")*/;
-var const$286 = new StringWrapper("/")/*const SourceString("/")*/;
-var const$287 = new StringWrapper("~/")/*const SourceString("~/")*/;
-var const$288 = new StringWrapper("%")/*const SourceString("%")*/;
-var const$289 = new StringWrapper("==")/*const SourceString("==")*/;
+var const$271 = new ExceptionImplementation("Internal Error (Leg): UNREACHABLE")/*const Exception("Internal Error (Leg): UNREACHABLE")*/;
+var const$276 = new StringWrapper("&&")/*const SourceString("&&")*/;
+var const$277 = new StringWrapper("||")/*const SourceString("||")*/;
+var const$278 = new StringWrapper("!")/*const SourceString("!")*/;
+var const$279 = new StringWrapper("+")/*const SourceString("+")*/;
+var const$280 = new StringWrapper("-")/*const SourceString("-")*/;
+var const$281 = new StringWrapper("*")/*const SourceString("*")*/;
+var const$282 = new StringWrapper("/")/*const SourceString("/")*/;
+var const$283 = new StringWrapper("~/")/*const SourceString("~/")*/;
+var const$284 = new StringWrapper("%")/*const SourceString("%")*/;
+var const$285 = new StringWrapper("==")/*const SourceString("==")*/;
+var const$286 = new StringWrapper("<")/*const SourceString("<")*/;
+var const$287 = new StringWrapper("<=")/*const SourceString("<=")*/;
+var const$288 = new StringWrapper(">")/*const SourceString(">")*/;
+var const$289 = new StringWrapper(">=")/*const SourceString(">=")*/;
 var const$29 = new Keyword("catch", false)/*const Keyword("catch")*/;
-var const$290 = new StringWrapper("<")/*const SourceString("<")*/;
-var const$291 = new StringWrapper("<=")/*const SourceString("<=")*/;
-var const$292 = new StringWrapper(">")/*const SourceString(">")*/;
-var const$293 = new StringWrapper(">=")/*const SourceString(">=")*/;
-var const$304 = ImmutableList.ImmutableList$from$factory(["__PROTO__", "prototype"])/*const <String>["__PROTO__", "prototype"]*/;
-var const$306 = 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"])/*const <String>[
+var const$300 = ImmutableList.ImmutableList$from$factory(["__PROTO__", "prototype"])/*const <String>["__PROTO__", "prototype"]*/;
+var const$302 = 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"])/*const <String>[
     // Section references are from Ecma-262
     // (http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf)
 
     // 15.1.1 Value Properties of the Global Object
     "NaN", "Infinity", "undefined",
 
     // 15.1.2 Function Properties of the Global Object
     "eval", "parseInt", "parseFloat", "isNan", "isFinite",
 
     // 15.1.3 URI Handling Function Properties
@@ skipping 110 matching lines @@
     // GWT-defined identifiers
     "\$wnd", "\$doc", "\$entry", "\$moduleName", "\$moduleBase",
     "\$gwt_version", "\$sessionId",
 
     // Identifiers used by JsStackEmulator; later set to obfuscatable
     "\$stack", "\$stackDepth", "\$location",
 
     // TODO: prove why this is necessary or remove it
     "call"
   ]*/;
-var const$308 = 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"])/*const <String>[
+var const$304 = 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"])/*const <String>[
     // These are current keywords
     "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",
 
     // These are future keywords
     "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 const$306 = new StringWrapper('guard\$num')/*const SourceString('guard\$num')*/;
 var const$31 = new Keyword("const", false)/*const Keyword("const")*/;
-var const$310 = new StringWrapper('guard\$num')/*const SourceString('guard\$num')*/;
 var const$33 = new Keyword("continue", false)/*const Keyword("continue")*/;
 var const$35 = new Keyword("default", false)/*const Keyword("default")*/;
 var const$37 = new Keyword("do", false)/*const Keyword("do")*/;
 var const$39 = new Keyword("else", false)/*const Keyword("else")*/;
 var const$4 = new StringWrapper('global scope')/*const SourceString('global scope')*/;
 var const$41 = new Keyword("false", false)/*const Keyword("false")*/;
 var const$423 = ImmutableList.ImmutableList$from$factory(['NullPointerException', 'ObjectNotClosureException', 'NoSuchMethodException', 'StackOverflowException'])/*const [
       'NullPointerException', 'ObjectNotClosureException',
       'NoSuchMethodException', 'StackOverflowException']*/;
 var const$43 = new Keyword("final", false)/*const Keyword("final")*/;
@@ skipping 69 matching lines @@
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 var $globals = {};
 $static_init();
 main();