Revert various changes to Link factories.

dart/frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 432 matching lines @@
 };
 Object.prototype.getBeginToken$0 = function() {
   return this.noSuchMethod("getBeginToken", []);
 };
 Object.prototype.getConstructor$1 = function($0) {
   return this.noSuchMethod("getConstructor", [$0]);
 };
 Object.prototype.getEndToken$0 = function() {
   return this.noSuchMethod("getEndToken", []);
 };
+Object.prototype.getFactory$2 = function($0, $1) {
+  return this.noSuchMethod("getFactory", [$0, $1]);
+};
 Object.prototype.getKeys$0 = function() {
   return this.noSuchMethod("getKeys", []);
 };
 Object.prototype.getMember$1 = function($0) {
   return this.noSuchMethod("getMember", [$0]);
 };
 Object.prototype.getOrMakeConcreteType$1 = function($0) {
   return this.noSuchMethod("getOrMakeConcreteType", [$0]);
 };
 Object.prototype.get_$3 = function($0, $1, $2) {
@@ skipping 936 matching lines @@
   return this.iterator();
 };
 ListFactory.prototype.last$0 = function() {
   return this.last();
 };
 ListFactory.prototype.removeLast$0 = function() {
   return this.removeLast();
 };
 ListFactory.prototype.some$1 = ListFactory.prototype.some;
 ListFactory.prototype.sort$1 = ListFactory.prototype.sort;
-ListFactory$DoubleLinkedQueueEntry$KeyValuePair$K$V = ListFactory;
-ListFactory$DoubleLinkedQueueEntry$KeyValuePair$Node$Element = ListFactory;
-ListFactory$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword = ListFactory;
 ListFactory$E = ListFactory;
-ListFactory$EvaluatedValue = ListFactory;
 ListFactory$HBasicBlock = ListFactory;
 ListFactory$HInstruction = ListFactory;
 ListFactory$K = ListFactory;
 ListFactory$KeywordState = ListFactory;
 ListFactory$String = ListFactory;
 ListFactory$T = ListFactory;
-ListFactory$Type = ListFactory;
 ListFactory$V = 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.hasNext = function() {
   return this._array.length > this._pos;
@@ skipping 214 matching lines @@
 // ********** Code for HashMapImplementation **************
 function HashMapImplementation() {
   // Initializers done
   if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   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$V(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.HashMapImplementation$from$factory = function(other) {
   var result = new HashMapImplementation();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
   })
   );
@@ skipping 55 matching lines @@
 HashMapImplementation._isPowerOfTwo = function(x) {
   return ((x & (x - 1)) == 0);
 }
 HashMapImplementation.prototype._grow = function(newCapacity) {
   $assert(HashMapImplementation._isPowerOfTwo(newCapacity), "_isPowerOfTwo(newCapacity)", "hash_map_set.dart", 153, 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$V(newCapacity);
+  this._values = new ListFactory(newCapacity);
   for (var i = 0;
    i < capacity; i++) {
     var key = oldKeys.$index(i);
     if (key == null || key === HashMapImplementation._deletedKey) {
       continue;
     }
     var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
@@ skipping 38 matching lines @@
 HashMapImplementation.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) !== HashMapImplementation._deletedKey)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation.prototype.getKeys = function() {
-  var list = new ListFactory$K(this.get$length());
+  var list = new ListFactory(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
   return list;
 }
 HashMapImplementation.prototype.getValues = function() {
-  var list = new ListFactory$V(this.get$length());
+  var list = new ListFactory(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, value);
   }
   );
   return list;
 }
 HashMapImplementation.prototype.containsKey = function(key) {
   return (this._probeForLookup(key) != -1);
 }
 HashMapImplementation.prototype.getKeys$0 = function() {
   return this.getKeys();
 };
 HashMapImplementation.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for HashMapImplementation$E$E **************
 function HashMapImplementation$E$E() {
   // Initializers done
   if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   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$E(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) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation$E$E._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
@@ skipping 47 matching lines @@
 HashMapImplementation$E$E._isPowerOfTwo = function(x) {
   return ((x & (x - 1)) == 0);
 }
 HashMapImplementation$E$E.prototype._grow = function(newCapacity) {
   $assert(HashMapImplementation._isPowerOfTwo(newCapacity), "_isPowerOfTwo(newCapacity)", "hash_map_set.dart", 153, 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$E(newCapacity);
+  this._values = new ListFactory(newCapacity);
   for (var i = 0;
    i < capacity; i++) {
     var key = oldKeys.$index(i);
     if (key == null || key === HashMapImplementation._deletedKey) {
       continue;
     }
     var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
@@ skipping 27 matching lines @@
 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) !== HashMapImplementation._deletedKey)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation$E$E.prototype.getKeys = function() {
-  var list = new ListFactory$E(this.get$length());
+  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) {
   return (this._probeForLookup(key) != -1);
 }
 // ********** Code for HashMapImplementation$Element$HInstruction **************
-function HashMapImplementation$Element$HInstruction() {
-  // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
-    HashMapImplementation._deletedKey = new Object();
-  }
-  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$HInstruction(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-}
+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;
-HashMapImplementation$Element$HInstruction.HashMapImplementation$from$factory = function(other) {
-  var result = new HashMapImplementation();
-  other.forEach((function (key, value) {
-    result.$setindex(key, value);
-  })
-  );
-  return (result && result.is$HashMapImplementation());
-}
-HashMapImplementation$Element$HInstruction._computeLoadLimit = function(capacity) {
-  return $truncdiv((capacity * 3), 4);
-}
 // ********** Code for HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V **************
-function HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V() {
-  // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
-    HashMapImplementation._deletedKey = new Object();
-  }
-  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$DoubleLinkedQueueEntry$KeyValuePair$K$V(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-}
+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;
-HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V._computeLoadLimit = function(capacity) {
-  return $truncdiv((capacity * 3), 4);
-}
-// ********** Code for HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element **************
-function HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element() {
-  // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
-    HashMapImplementation._deletedKey = new Object();
-  }
-  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$DoubleLinkedQueueEntry$KeyValuePair$Node$Element(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-}
-$inherits(HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element, HashMapImplementation);
-HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element.prototype.is$Map$Node$Element = false;
-HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element.prototype.is$Map$String$Member = false;
-HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element._computeLoadLimit = function(capacity) {
-  return $truncdiv((capacity * 3), 4);
-}
-// ********** Code for HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword **************
-function HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword() {
-  // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
-    HashMapImplementation._deletedKey = new Object();
-  }
-  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$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-}
-$inherits(HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword, HashMapImplementation);
-HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword.prototype.is$Map$Node$Element = false;
-HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword.prototype.is$Map$String$Member = false;
-HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword._computeLoadLimit = function(capacity) {
-  return $truncdiv((capacity * 3), 4);
-}
 // ********** Code for HashMapImplementation$String$EvaluatedValue **************
-function HashMapImplementation$String$EvaluatedValue() {
-  // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
-    HashMapImplementation._deletedKey = new Object();
-  }
-  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$EvaluatedValue(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-}
+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;
-HashMapImplementation$String$EvaluatedValue._computeLoadLimit = function(capacity) {
-  return $truncdiv((capacity * 3), 4);
-}
-// ********** Code for HashMapImplementation$String$String **************
-function HashMapImplementation$String$String() {
-  // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
-    HashMapImplementation._deletedKey = new Object();
-  }
-  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$String(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-}
-$inherits(HashMapImplementation$String$String, HashMapImplementation);
-HashMapImplementation$String$String.prototype.is$Map$Node$Element = false;
-HashMapImplementation$String$String.prototype.is$Map$String$Member = false;
-HashMapImplementation$String$String._computeLoadLimit = function(capacity) {
-  return $truncdiv((capacity * 3), 4);
-}
-// ********** Code for HashMapImplementation$Type$Type **************
-function HashMapImplementation$Type$Type() {
-  // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
-    HashMapImplementation._deletedKey = new Object();
-  }
-  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$Type(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-}
-$inherits(HashMapImplementation$Type$Type, HashMapImplementation);
-HashMapImplementation$Type$Type.prototype.is$Map$Node$Element = false;
-HashMapImplementation$Type$Type.prototype.is$Map$String$Member = false;
-HashMapImplementation$Type$Type._computeLoadLimit = function(capacity) {
-  return $truncdiv((capacity * 3), 4);
-}
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
   // Initializers done
   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$Iterable = function(){return this;};
@@ skipping 23 matching lines @@
   }
   );
 }
 HashSetImplementation.prototype.forEach = function(f) {
   this._backingMap.forEach(function _(key, value) {
     f(key);
   }
   );
 }
 HashSetImplementation.prototype.filter = function(f) {
-  var result = new HashSetImplementation$E();
+  var result = new HashSetImplementation();
   this._backingMap.forEach(function _(key, value) {
     if (f(key)) result.add(key);
   }
   );
   return result;
 }
 HashSetImplementation.prototype.some = function(f) {
   var keys = this._backingMap.getKeys();
   return $assert_bool(keys.some(f));
 }
@@ skipping 16 matching lines @@
 HashSetImplementation.prototype.contains$1 = HashSetImplementation.prototype.contains;
 HashSetImplementation.prototype.filter$1 = HashSetImplementation.prototype.filter;
 HashSetImplementation.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 HashSetImplementation.prototype.iterator$0 = function() {
   return this.iterator();
 };
 HashSetImplementation.prototype.some$1 = HashSetImplementation.prototype.some;
 // ********** Code for HashSetImplementation$E **************
-function HashSetImplementation$E() {
-  // Initializers done
-  this._backingMap = new HashMapImplementation$E$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$String **************
-function HashSetImplementation$String() {
-  // Initializers done
-  this._backingMap = new HashMapImplementation$String$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() {
-  // Initializers done
-  this._backingMap = new HashMapImplementation$Type$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 HashSetIterator **************
 function HashSetIterator(set_) {
   this._nextValidIndex = -1;
   this._entries = set_._backingMap._keys;
   // Initializers done
@@ skipping 58 matching lines @@
 }
 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) {
   this.key = key;
   this.value = value;
   // Initializers done
 }
 $inherits(KeyValuePair$K$V, KeyValuePair);
-// ********** Code for KeyValuePair$Node$Element **************
-function KeyValuePair$Node$Element() {}
-$inherits(KeyValuePair$Node$Element, KeyValuePair);
-// ********** Code for KeyValuePair$String$Keyword **************
-function KeyValuePair$String$Keyword() {}
-$inherits(KeyValuePair$String$Keyword, KeyValuePair);
 // ********** Code for LinkedHashMapImplementation **************
 function LinkedHashMapImplementation() {
   // Initializers done
-  this._map = new HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V();
+  this._map = new HashMapImplementation();
   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.$setindex = function(key, value) {
   if (this._map.containsKey(key)) {
     this._map.$index(key).get$element().value = value;
   }
   else {
     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());
   if (entry == null) return null;
   return entry.get$element().get$value();
 }
 LinkedHashMapImplementation.prototype.getKeys = function() {
-  var list = new ListFactory$K(this.get$length());
+  var list = new ListFactory(this.get$length());
   var index = 0;
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.key);
   }
   );
   $assert(index == this.get$length(), "index == length", "linked_hash_map.dart", 75, 12);
   return list;
 }
 LinkedHashMapImplementation.prototype.getValues = function() {
-  var list = new ListFactory$V(this.get$length());
+  var list = new ListFactory(this.get$length());
   var index = 0;
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.value);
   }
   );
   $assert(index == this.get$length(), "index == length", "linked_hash_map.dart", 86, 12);
   return list;
 }
 LinkedHashMapImplementation.prototype.forEach = function(f) {
   this._list.forEach(function _(entry) {
@@ skipping 13 matching lines @@
 LinkedHashMapImplementation.prototype.isEmpty = function() {
   return this.get$length() == 0;
 }
 LinkedHashMapImplementation.prototype.getKeys$0 = function() {
   return this.getKeys();
 };
 LinkedHashMapImplementation.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for LinkedHashMapImplementation$Node$Element **************
-function LinkedHashMapImplementation$Node$Element() {
-  // Initializers done
-  this._map = new HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element();
-  this._list = new DoubleLinkedQueue$KeyValuePair$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() {
-  // Initializers done
-  this._map = new HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword();
-  this._list = new DoubleLinkedQueue$KeyValuePair$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._link = function(p, n) {
@@ skipping 53 matching lines @@
 // ********** 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._asNonSentinelEntry = function() {
   return this;
 }
-// ********** Code for DoubleLinkedQueueEntry$KeyValuePair$Node$Element **************
-function DoubleLinkedQueueEntry$KeyValuePair$Node$Element() {}
-$inherits(DoubleLinkedQueueEntry$KeyValuePair$Node$Element, DoubleLinkedQueueEntry);
-DoubleLinkedQueueEntry$KeyValuePair$Node$Element.prototype.is$DoubleLinkedQueueEntry$KeyValuePair$K$V = function(){return this;};
-// ********** Code for DoubleLinkedQueueEntry$KeyValuePair$String$Keyword **************
-function DoubleLinkedQueueEntry$KeyValuePair$String$Keyword() {}
-$inherits(DoubleLinkedQueueEntry$KeyValuePair$String$Keyword, DoubleLinkedQueueEntry);
-DoubleLinkedQueueEntry$KeyValuePair$String$Keyword.prototype.is$DoubleLinkedQueueEntry$KeyValuePair$K$V = function(){return this;};
 // ********** Code for _DoubleLinkedQueueEntrySentinel **************
 function _DoubleLinkedQueueEntrySentinel() {
   DoubleLinkedQueueEntry$E.call(this, null);
   // Initializers done
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel, DoubleLinkedQueueEntry$E);
 _DoubleLinkedQueueEntrySentinel.prototype.remove = function() {
   $throw(const$9/*const EmptyQueueException()*/);
 }
@@ skipping 35 matching lines @@
   p._next = this;
   n._previous = this;
 }
 _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V.prototype.prepend = function(e) {
   new DoubleLinkedQueueEntry$KeyValuePair$K$V(e)._link(this._previous, this);
 }
 _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V.prototype.previousEntry = function() {
   var $0;
   return (($0 = this._previous._asNonSentinelEntry()) && $0.is$DoubleLinkedQueueEntry$KeyValuePair$K$V());
 }
-// ********** Code for _DoubleLinkedQueueEntrySentinel$KeyValuePair$Node$Element **************
-function _DoubleLinkedQueueEntrySentinel$KeyValuePair$Node$Element() {
-  DoubleLinkedQueueEntry$E.call(this, null);
-  // Initializers done
-  this._link(this, this);
-}
-$inherits(_DoubleLinkedQueueEntrySentinel$KeyValuePair$Node$Element, _DoubleLinkedQueueEntrySentinel);
-_DoubleLinkedQueueEntrySentinel$KeyValuePair$Node$Element.prototype._link = function(p, n) {
-  this._next = n;
-  this._previous = p;
-  p._next = this;
-  n._previous = this;
-}
-// ********** Code for _DoubleLinkedQueueEntrySentinel$KeyValuePair$String$Keyword **************
-function _DoubleLinkedQueueEntrySentinel$KeyValuePair$String$Keyword() {
-  DoubleLinkedQueueEntry$E.call(this, null);
-  // Initializers done
-  this._link(this, this);
-}
-$inherits(_DoubleLinkedQueueEntrySentinel$KeyValuePair$String$Keyword, _DoubleLinkedQueueEntrySentinel);
-_DoubleLinkedQueueEntrySentinel$KeyValuePair$String$Keyword.prototype._link = function(p, n) {
-  this._next = n;
-  this._previous = p;
-  p._next = this;
-  n._previous = this;
-}
 // ********** Code for DoubleLinkedQueue **************
 function DoubleLinkedQueue() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$E();
 }
 DoubleLinkedQueue.prototype.is$DoubleLinkedQueue = 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;};
@@ skipping 49 matching lines @@
 }
 DoubleLinkedQueue.prototype.some = function(f) {
   var entry = this._sentinel._next;
   while (entry !== this._sentinel) {
     if (f(entry._element)) return true;
     entry = entry._next;
   }
   return false;
 }
 DoubleLinkedQueue.prototype.filter = function(f) {
-  var other = new DoubleLinkedQueue$E();
+  var other = new DoubleLinkedQueue();
   var entry = this._sentinel._next;
   while (entry !== this._sentinel) {
     if (f(entry._element)) other.addLast(entry._element);
     entry = entry._next;
   }
   return other;
 }
 DoubleLinkedQueue.prototype.iterator = function() {
   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()));
 };
 DoubleLinkedQueue.prototype.filter$1 = DoubleLinkedQueue.prototype.filter;
 DoubleLinkedQueue.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 DoubleLinkedQueue.prototype.iterator$0 = function() {
   return this.iterator();
 };
 DoubleLinkedQueue.prototype.last$0 = function() {
   return this.last();
 };
 DoubleLinkedQueue.prototype.removeLast$0 = function() {
   return this.removeLast();
 };
 DoubleLinkedQueue.prototype.some$1 = DoubleLinkedQueue.prototype.some;
 // ********** Code for DoubleLinkedQueue$E **************
-function DoubleLinkedQueue$E() {
-  // Initializers done
-  this._sentinel = new _DoubleLinkedQueueEntrySentinel$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$KeyValuePair$K$V **************
 function DoubleLinkedQueue$KeyValuePair$K$V() {
   // Initializers done
   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) {
   this._sentinel.prepend(value);
 }
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.lastEntry = function() {
   return this._sentinel.previousEntry();
 }
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while (entry !== this._sentinel) {
     f(entry._element);
     entry = entry._next;
   }
 }
-// ********** Code for DoubleLinkedQueue$KeyValuePair$Node$Element **************
-function DoubleLinkedQueue$KeyValuePair$Node$Element() {
-  // Initializers done
-  this._sentinel = new _DoubleLinkedQueueEntrySentinel$KeyValuePair$Node$Element();
-}
-$inherits(DoubleLinkedQueue$KeyValuePair$Node$Element, DoubleLinkedQueue);
-DoubleLinkedQueue$KeyValuePair$Node$Element.prototype.is$Collection$E = function(){return this;};
-DoubleLinkedQueue$KeyValuePair$Node$Element.prototype.is$Collection$Object = function(){return this;};
-DoubleLinkedQueue$KeyValuePair$Node$Element.prototype.is$Collection$Type = false;
-DoubleLinkedQueue$KeyValuePair$Node$Element.prototype.is$Iterable = function(){return this;};
-// ********** Code for DoubleLinkedQueue$KeyValuePair$String$Keyword **************
-function DoubleLinkedQueue$KeyValuePair$String$Keyword() {
-  // Initializers done
-  this._sentinel = new _DoubleLinkedQueueEntrySentinel$KeyValuePair$String$Keyword();
-}
-$inherits(DoubleLinkedQueue$KeyValuePair$String$Keyword, DoubleLinkedQueue);
-DoubleLinkedQueue$KeyValuePair$String$Keyword.prototype.is$Collection$E = function(){return this;};
-DoubleLinkedQueue$KeyValuePair$String$Keyword.prototype.is$Collection$Object = function(){return this;};
-DoubleLinkedQueue$KeyValuePair$String$Keyword.prototype.is$Collection$Type = false;
-DoubleLinkedQueue$KeyValuePair$String$Keyword.prototype.is$Iterable = function(){return this;};
 // ********** Code for DoubleLinkedQueue$SourceString **************
 function DoubleLinkedQueue$SourceString() {}
 $inherits(DoubleLinkedQueue$SourceString, DoubleLinkedQueue);
 DoubleLinkedQueue$SourceString.prototype.is$Collection$E = function(){return this;};
 DoubleLinkedQueue$SourceString.prototype.is$Collection$Object = function(){return this;};
 DoubleLinkedQueue$SourceString.prototype.is$Collection$Type = false;
 DoubleLinkedQueue$SourceString.prototype.is$Iterable = function(){return this;};
-DoubleLinkedQueue$SourceString.DoubleLinkedQueue$from$factory = function(other) {
-  var list = new DoubleLinkedQueue();
-  for (var $i = other.iterator(); $i.hasNext$0(); ) {
-    var e = $i.next$0();
-    list.addLast(e);
-  }
-  return (list && list.is$DoubleLinkedQueue());
-}
 // ********** 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.hasNext = function() {
   return this._currentEntry._next !== this._sentinel;
 }
@@ skipping 77 matching lines @@
   return this;
 }
 StringBufferImpl.prototype.addAll = function(objects) {
   for (var $i = objects.iterator(); $i.hasNext$0(); ) {
     var obj = $i.next$0();
     this.add(obj);
   }
   return this;
 }
 StringBufferImpl.prototype.clear = function() {
-  this._buffer = new ListFactory$String();
+  this._buffer = new ListFactory();
   this._length = 0;
   return this;
 }
 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;
@@ skipping 312 matching lines @@
 // ********** Code for top level **************
 function join(strings) {
   return Strings.join(strings, '/');
 }
 function readSync(fileName) {
   return new SourceFile(fileName, world.files.readAll(fileName));
 }
 //  ********** Library util_implementation **************
 // ********** Code for LinkFactory **************
 function LinkFactory() {}
-LinkFactory.createLink = function(head, tail) {
+LinkFactory.Link$factory = function(head, tail) {
   var $0;
   return new LinkEntry(head, (($0 = (tail == null) ? const$18/*const EmptyLink()*/ : tail) && $0.is$Link$T()));
 }
+// ********** Code for LinkFactory$Node **************
+function LinkFactory$Node() {}
+$inherits(LinkFactory$Node, LinkFactory);
+// ********** Code for LinkFactory$T **************
+function LinkFactory$T() {}
+$inherits(LinkFactory$T, LinkFactory);
 // ********** Code for AbstractLink **************
 function AbstractLink() {}
 AbstractLink.prototype.is$Link = function(){return this;};
 AbstractLink.prototype.is$Link$Element = function(){return this;};
 AbstractLink.prototype.is$Link$Node = function(){return this;};
 AbstractLink.prototype.is$Link$T = function(){return this;};
 AbstractLink.prototype.is$Link$Token = function(){return this;};
 AbstractLink.prototype.is$Link$Type = function(){return this;};
 AbstractLink.prototype.is$Iterable = function(){return this;};
 AbstractLink.prototype.get$head = function() {
   $throw("bug");
 }
 AbstractLink.prototype.get$tail = function() {
   $throw("bug");
 }
 AbstractLink.prototype.prepend = function(element) {
-  return LinkFactory.createLink(element, this);
+  return LinkFactory.Link$factory(element, this);
 }
 AbstractLink.prototype.iterator = function() {
   var $0;
   return (($0 = this.toList().iterator$0()) && $0.is$Iterator$T());
 }
 AbstractLink.prototype.printOn = function(buffer, separatedBy) {
   var $0;
   if ($notnull_bool(this.isEmpty())) return;
   buffer.add(this.get$head() == null ? 'null' : this.get$head());
   if (separatedBy == null) separatedBy = '';
@@ skipping 57 matching lines @@
 LinkTail.prototype.toList = function() {
   return const$5/*const <HInstruction>[]*/;
 }
 LinkTail.prototype.isEmpty = function() {
   return true;
 }
 LinkTail.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for LinkTail$Node **************
-function LinkTail$Node() {
-  // Initializers done
-}
+function LinkTail$Node() {}
 $inherits(LinkTail$Node, LinkTail);
 LinkTail$Node.prototype.is$Link = function(){return this;};
 LinkTail$Node.prototype.is$Link$Element = function(){return this;};
 LinkTail$Node.prototype.is$Link$Node = function(){return this;};
 LinkTail$Node.prototype.is$Link$T = function(){return this;};
 LinkTail$Node.prototype.is$Link$Token = function(){return this;};
 LinkTail$Node.prototype.is$Link$Type = function(){return this;};
 LinkTail$Node.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkEntry **************
 function LinkEntry(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
 }
 $inherits(LinkEntry, AbstractLink$T);
 LinkEntry.prototype.get$head = function() { return this.head; };
 LinkEntry.prototype.get$tail = function() {
   return this.realTail;
 }
 LinkEntry.prototype.isEmpty = function() {
   return false;
 }
 LinkEntry.prototype.toList = function() {
   var $0;
-  var list = new ListFactory$T();
+  var list = new ListFactory();
   for (var link = this;
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$T())) {
     list.addLast(link.get$head());
   }
   return list;
 }
 LinkEntry.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for LinkEntry$T **************
@@ skipping 23 matching lines @@
   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$Type **************
-function LinkBuilderImplementation$Type() {
-  this.head = null
-  this.lastLink = null
-  // Initializers done
-}
+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$18/*const EmptyLink()*/
   this.extraCharOffset = 0;
   this.tokenStart = -1;
@@ skipping 4265 matching lines @@
 NodeListener.prototype.handleLiteralDouble = function(token) {
   this.pushNode(new LiteralDouble(token, to$call$2(this.onError)));
 }
 NodeListener.prototype.handleLiteralBool = function(token) {
   this.pushNode(new LiteralBool(token, to$call$2(this.onError)));
 }
 NodeListener.prototype.handleLiteralString = function(token) {
   this.pushNode(new LiteralString(token));
 }
 NodeListener.prototype.handleBinaryExpression = function(token) {
-  var arguments = new NodeList(null, LinkFactory.createLink(this.popNode()), null, null);
+  var arguments = new NodeList(null, LinkFactory.Link$factory(this.popNode()), null, null);
   this.pushNode(new Send(this.popNode(), new Operator(token), arguments));
 }
 NodeListener.prototype.handleAssignmentExpression = function(token) {
   var arguments = new NodeList.singleton$ctor(this.popNode());
   var node = this.popNode();
   if (!(node instanceof Send)) this.canceler.cancel(('not assignable: ' + node + ''));
   var send = (node && node.is$Send());
   if (!$notnull_bool(send.get$isPropertyAccess())) this.canceler.cancel(('not assignable: ' + node + ''));
   if ((send instanceof SendSet)) this.canceler.cancel('chained assignment');
   this.pushNode(new SendSet(send.receiver, send.selector, token, arguments));
@@ skipping 363 matching lines @@
   // Initializers done
 }
 Keyword.prototype.is$SourceString = function(){return this;};
 Keyword.get$keywords = function() {
   if (Keyword._keywords == null) {
     Keyword._keywords = Keyword.computeKeywordMap();
   }
   return Keyword._keywords;
 }
 Keyword.computeKeywordMap = function() {
-  var result = new LinkedHashMapImplementation$String$Keyword();
+  var result = new LinkedHashMapImplementation();
   for (var $i0 = const$236/*Keyword.values*/.iterator(); $i0.hasNext(); ) {
     var keyword = $i0.next();
     result.$setindex(keyword.syntax, keyword);
   }
   return result;
 }
 Keyword.prototype.hashCode = function() {
   return this.syntax.hashCode();
 }
 Keyword.prototype.$eq = function(other) {
@@ skipping 15 matching lines @@
   return this.printOn(($0 && $0.is$StringBuffer()));
 };
 Keyword.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for KeywordState **************
 function KeywordState() {}
 KeywordState.prototype.is$KeywordState = function(){return this;};
 KeywordState.get$KEYWORD_STATE = function() {
   if (KeywordState._KEYWORD_STATE == null) {
-    var strings = new ListFactory$String(const$236/*Keyword.values*/.get$length());
+    var strings = new ListFactory(const$236/*Keyword.values*/.get$length());
     for (var i = 0;
      i < const$236/*Keyword.values*/.get$length(); i++) {
       strings.$setindex(i, const$236/*Keyword.values*/[i].syntax);
     }
     strings.sort((function (a, b) {
       return a.compareTo$1(b);
     })
     );
     KeywordState._KEYWORD_STATE = KeywordState.computeKeywordStateTable(0, strings, 0, strings.length);
   }
   return KeywordState._KEYWORD_STATE;
 }
 KeywordState.computeKeywordStateTable = function(start, strings, offset, length) {
-  var result = new ListFactory$KeywordState(26);
+  var result = new ListFactory(26);
   $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 = 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));
@@ skipping 217 matching lines @@
 };
 // ********** Code for NodeList **************
 function NodeList(beginToken, nodes, endToken, delimiter) {
   this.beginToken = beginToken;
   this.nodes = nodes;
   this.endToken = endToken;
   this.delimiter = delimiter;
   // Initializers done
 }
 NodeList.singleton$ctor = function(node) {
-  NodeList.call(this, null, LinkFactory.createLink(node));
+  NodeList.call(this, null, LinkFactory.Link$factory(node));
   // Initializers done
 }
 NodeList.singleton$ctor.prototype = NodeList.prototype;
 $inherits(NodeList, Node);
 NodeList.prototype.is$NodeList = function(){return this;};
 NodeList.prototype.accept = function(visitor) {
   return visitor.visitNodeList(this);
 }
 NodeList.prototype.getBeginToken = function() {
   var $0;
@@ skipping 669 matching lines @@
   Element.call(this, name, const$243, null);
   // Initializers done
 }
 $inherits(FunctionElement, Element);
 FunctionElement.prototype.computeType = function(compiler, types) {
   var $0;
   if (this.type != null) return (($0 = this.type) && $0.is$FunctionType());
   var node = (($0 = this.parseNode(compiler, compiler)) && $0.is$FunctionExpression());
   var returnType = getType(node.returnType, types);
   if (returnType == null) compiler.cancel(('unknown type ' + returnType + ''));
-  var parameterTypes = new LinkBuilderImplementation$Type();
+  var parameterTypes = new LinkBuilderImplementation();
   for (var link = node.parameters.nodes;
    !$notnull_bool(link.isEmpty$0()); link = link.get$tail()) {
     var parameter = (($0 = link.get$head()) && $0.is$VariableDefinitions());
     parameterTypes.addLast(getType(parameter.type, types));
   }
   this.type = new FunctionType(returnType, (($0 = parameterTypes.toLink()) && $0.is$Link$Type()));
   return (($0 = this.type) && $0.is$FunctionType());
 }
 FunctionElement.prototype.computeType$2 = FunctionElement.prototype.computeType;
 // ********** Code for ClassElement **************
@@ skipping 47 matching lines @@
   return graph;
 }
 // ********** Code for SsaBuilder **************
 function SsaBuilder(compiler, elements) {
   this.compiler = compiler;
   this.elements = elements;
   // Initializers done
 }
 SsaBuilder.prototype.is$Visitor = function(){return this;};
 SsaBuilder.prototype.build = function(parameters, body) {
-  this.stack = new ListFactory$HInstruction();
-  this.definitions = new HashMapImplementation$Element$HInstruction();
+  this.stack = new ListFactory();
+  this.definitions = new HashMapImplementation();
   this.graph = new HGraph();
   var block = this.graph.addNewBlock();
   this.open(this.graph.entry);
   this.visitParameters(parameters);
   this.close(new HGoto()).addSuccessor(block);
   this.open(block);
   body.accept(this);
   if (!$notnull_bool(this.isAborted())) this.close(new HGoto()).addSuccessor(this.graph.exit);
   this.graph.finalize();
   return this.graph;
@@ skipping 134 matching lines @@
   var element = (($0 = this.elements.$index(node)) && $0.is$Element());
   this.compiler.ensure(element != null);
   var def = (($0 = this.definitions.$index(element)) && $0.is$HInstruction());
   $assert(def != null, "def !== null", "builder.dart", 240, 12);
   this.stack.add(def);
 }
 SsaBuilder.prototype.joinDefinitions = function(joinBlock, incoming1, incoming2) {
   if (incoming1.get$length() > incoming2.get$length()) {
     return this.joinDefinitions(joinBlock, incoming2, incoming1);
   }
-  var joinedDefinitions = new HashMapImplementation$Element$HInstruction();
+  var joinedDefinitions = new HashMapImplementation();
   $assert(incoming1.get$length() <= incoming2.get$length(), "incoming1.length <= incoming2.length", "builder.dart", 259, 12);
   incoming1.forEach((function (element, instruction) {
     var $0;
     var other = (($0 = incoming2.$index(element)) && $0.is$HInstruction());
     if (other == null) return;
     if (instruction === other) {
       joinedDefinitions.$setindex(element, instruction);
     }
     else {
       var phi = new HPhi.manyInputs$ctor(element, [instruction, other]);
@@ skipping 477 matching lines @@
 HInstructionVisitor.prototype.visitBasicBlock = function(node) {
   this.currentBlock = node;
   var instruction = node.first;
   while (instruction != null) {
     this.visitInstruction(instruction);
     instruction = instruction.next;
   }
 }
 // ********** Code for HGraph **************
 function HGraph() {
-  this.blocks = new ListFactory$HBasicBlock();
+  this.blocks = new ListFactory();
   // Initializers done
   this.entry = this.addNewBlock();
   this.exit = new HBasicBlock();
 }
 HGraph.prototype.is$HGraph = function(){return this;};
 HGraph.prototype.addBlock = function(block) {
   var id = this.blocks.length;
   block.id = id;
   this.blocks.add(block);
   $assert(this.blocks.$index(id) === block, "blocks[id] === block", "nodes.dart", 85, 12);
@@ skipping 1460 matching lines @@
 }
 ErrorMessages.cannotResolveType = function(id) {
   return ("cannot resolve type " + id + "");
 }
 ErrorMessages.duplicateDefinition = function(id) {
   return ("duplicate definition of " + id + "");
 }
 // ********** Code for ResolverVisitor **************
 function ResolverVisitor(compiler) {
   this.compiler = compiler;
-  this.mapping = new LinkedHashMapImplementation$Node$Element();
+  this.mapping = new LinkedHashMapImplementation();
   this.context = new Scope(new TopScope(compiler.universe));
   // Initializers done
 }
 ResolverVisitor.prototype.is$Visitor = function(){return this;};
 ResolverVisitor.prototype.fail = function(node, message) {
   this.compiler.cancel(message);
 }
 ResolverVisitor.prototype.warning = function(node, message) {
   this.compiler.reportWarning(node, message);
 }
@@ skipping 1054 matching lines @@
   return (factType && factType.is$lang_Type());
 }
 // ********** Code for BlockScope **************
 function BlockScope(enclosingMethod, parent, reentrant) {
   this.enclosingMethod = enclosingMethod;
   this.parent = parent;
   this.reentrant = reentrant;
   this._vars = $map([]);
   // Initializers done
   if ($notnull_bool(this.get$isMethodScope())) {
-    this._closedOver = new HashSetImplementation$String();
+    this._closedOver = new HashSetImplementation();
   }
   else {
     this.reentrant = $notnull_bool(this.reentrant || this.parent.reentrant);
   }
 }
 BlockScope.prototype.is$BlockScope = function(){return this;};
 BlockScope.prototype.get$parent = function() { return this.parent; };
 BlockScope.prototype.set$parent = function(value) { return this.parent = value; };
 BlockScope.prototype.get$isMethodScope = function() {
   return this.parent == null || $ne(this.parent.enclosingMethod, this.enclosingMethod);
@@ skipping 2836 matching lines @@
       }
       if ($notnull_bool(arg == null || !$notnull_bool(this.parameters.$index(i).get$isOptional()))) {
         var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + 1, true);
         return this._argError(context, node, target, args, $assert_String(msg));
       }
       else {
         argsCode.add$1($notnull_bool(this.isConst && arg.get$isConst()) ? arg.get$canonicalCode() : arg.code);
       }
     }
     if (namedArgsUsed < args.get$nameCount()) {
-      var seen = new HashSetImplementation$String();
+      var seen = new HashSetImplementation();
       for (var i = bareCount;
        i < args.get$length(); i++) {
         var name = args.getName(i);
         if ($notnull_bool(seen.contains$1(name))) {
           return this._argError(context, node, target, args, ('duplicate argument "' + name + '"'));
         }
         seen.add$1(name);
         var p = this.indexOfParameter($assert_String(name));
         if (p < 0) {
           return this._argError(context, node, target, args, ('method does not have optional parameter "' + name + '"'));
@@ skipping 57 matching lines @@
     if ($notnull_bool($notnull_bool(this.isConst && (node instanceof lang_NewExpression)) && node.get$dynamic().get$isConst())) {
       return this._invokeConstConstructor(node, $assert_String(code), target, args);
     }
     else {
       return new Value(this.declaringType, code, node.span, true);
     }
   }
 }
 MethodMember.prototype._invokeConstConstructor = function(node, code, target, args) {
   var $0;
-  var fields = new HashMapImplementation$String$EvaluatedValue();
+  var fields = new HashMapImplementation();
   for (var i = 0;
    i < this.parameters.length; i++) {
     var param = this.parameters.$index(i);
     if ($notnull_bool(param.isInitializer)) {
       var value = null;
       if (i < args.get$length()) {
         value = args.values.$index(i);
       }
       else {
         value = args.getValue($assert_String(param.get$name()));
@@ skipping 629 matching lines @@
 }
 FactoryMap.prototype.forEach = function(f) {
   this.factories.forEach((function (_, constructors) {
     constructors.forEach((function (_, member) {
       f(member);
     })
     );
   })
   );
 }
+FactoryMap.prototype.getFactory$2 = function($0, $1) {
+  return this.getFactory($assert_String($0), $assert_String($1));
+};
 // ********** Code for lang_Token **************
 function lang_Token(kind, source, start, end) {
   this.kind = kind;
   this.source = source;
   this.start = start;
   this.end = end;
   // Initializers done
 }
 lang_Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
@@ skipping 4439 matching lines @@
 }
 lang_Type.prototype.addDirectSubtype$1 = function($0) {
   return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 lang_Type.prototype.ensureSubtypeOf$3 = function($0, $1, $2) {
   return this.ensureSubtypeOf(($0 && $0.is$lang_Type()), ($1 && $1.is$SourceSpan()), $assert_bool($2));
 };
 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()));
 };
 lang_Type.prototype.hashCode$0 = function() {
   return this.hashCode();
 };
 lang_Type.prototype.isAssignable$1 = function($0) {
@@ skipping 193 matching lines @@
 }
 NonNullableType.prototype.get$isNativeType = function() {
   return this.type.get$isNativeType();
 }
 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()));
 };
 NonNullableType.prototype.isSubtypeOf$1 = function($0) {
   return this.isSubtypeOf(($0 && $0.is$lang_Type()));
 };
 NonNullableType.prototype.markUsed$0 = function() {
@@ skipping 102 matching lines @@
 ConcreteType.prototype.getConstructor = function(constructorName) {
   var ret = this.constructors.$index(constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   var genericMember = this.genericType.getConstructor(constructorName);
   if ($notnull_bool(genericMember == null)) return null;
   if ($ne(genericMember.declaringType, this.genericType)) {
     if (!$notnull_bool(genericMember.declaringType.get$isGeneric())) return genericMember;
     var newDeclaringType = genericMember.declaringType.getOrMakeConcreteType(this.typeArgsInOrder);
+    var factory = newDeclaringType.getFactory$2(this.genericType, constructorName);
+    if (factory != null) return factory;
     return newDeclaringType.getConstructor$1(constructorName);
   }
   if ($notnull_bool(genericMember.get$isFactory())) {
     ret = new ConcreteMember($assert_String(genericMember.get$name()), this, genericMember);
     this.factories.addFactory(this.name, constructorName, (ret && ret.is$Member()));
   }
   else {
     ret = new ConcreteMember(this.name, this, genericMember);
     this.constructors.$setindex(constructorName, ret);
   }
@@ skipping 27 matching lines @@
 }
 ConcreteType.prototype.addDirectSubtype = function(type) {
   this.genericType.addDirectSubtype(type);
 }
 ConcreteType.prototype.addDirectSubtype$1 = function($0) {
   return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 ConcreteType.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
+ConcreteType.prototype.getFactory$2 = function($0, $1) {
+  return this.getFactory(($0 && $0.is$lang_Type()), $assert_String($1));
+};
 ConcreteType.prototype.getMember$1 = function($0) {
   return this.getMember($assert_String($0));
 };
 ConcreteType.prototype.getOrMakeConcreteType$1 = function($0) {
   return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
 };
 ConcreteType.prototype.markUsed$0 = function() {
   return this.markUsed();
 };
 ConcreteType.prototype.resolveMember$1 = function($0) {
   return this.resolveMember($assert_String($0));
 };
 ConcreteType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 // ********** Code for DefinedType **************
 function DefinedType(name, library, definition, isClass) {
   this.isUsed = false
   this.isNativeType = false
   this.library = library;
   this.isClass = isClass;
-  this.directSubtypes = new HashSetImplementation$Type();
+  this.directSubtypes = new HashSetImplementation();
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
   this._resolvedMembers = $map([]);
   lang_Type.call(this, name);
   // Initializers done
   this.setDefinition(definition);
 }
 $inherits(DefinedType, lang_Type);
 DefinedType.prototype.is$DefinedType = function(){return this;};
@@ skipping 15 matching lines @@
 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.setDefinition = function(def) {
-  $assert(this.definition == null, "definition == null", "type.dart", 628, 12);
+  $assert(this.definition == null, "definition == null", "type.dart", 630, 12);
   this.definition = def;
   if ((this.definition instanceof TypeDefinition) && this.definition.get$nativeType() != null) {
     this.isNativeType = true;
   }
   if (this.definition != null && 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);
@@ skipping 88 matching lines @@
     var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
     if ($notnull_bool(resolvedInterface.get$isClosed() && !($notnull_bool(this.library.get$isCore() || this.library.get$isCoreImpl())))) {
       world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', type.get$span());
     }
     resolvedInterface.addDirectSubtype$1(this);
     interfaces.add$1(resolvedInterface);
   }
   return (interfaces && interfaces.is$List$Type());
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
-  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 744, 12);
+  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 746, 12);
   this.directSubtypes.add(type);
 }
 DefinedType.prototype.get$subtypes = function() {
   if (this._subtypes == null) {
-    this._subtypes = new HashSetImplementation$Type();
+    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(st.get$subtypes());
     }
   }
   return this._subtypes;
 }
 DefinedType.prototype._cycleInClassExtends = function() {
@@ skipping 401 matching lines @@
   }
   else {
     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", 1227, 12);
+  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1229, 12);
   var names = [this.name];
   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());
   }
   var concreteName = Strings.join((names && names.is$List$String()), '\$');
   var ret = this._concreteTypes.$index(concreteName);
   if ($notnull_bool(ret == null)) {
     ret = new ConcreteType($assert_String(concreteName), this, typeMap, typeArgs);
     this._concreteTypes.$setindex(concreteName, ret);
   }
   return (ret && ret.is$lang_Type());
 }
 DefinedType.prototype.getCallStub = function(args) {
-  $assert(this.get$isFunction(), "isFunction", "type.dart", 1247, 12);
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1249, 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()));
 };
 DefinedType.prototype.markUsed$0 = function() {
   return this.markUsed();
 };
 DefinedType.prototype.resolve$0 = function() {
@@ skipping 19 matching lines @@
 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);
 }
 FixedCollection.prototype.forEach = function(f) {
   Collections.forEach(this, f);
 }
 FixedCollection.prototype.filter = function(f) {
-  return Collections.filter(this, new ListFactory$E(), f);
+  return Collections.filter(this, new ListFactory(), f);
 }
 FixedCollection.prototype.some = function(f) {
   return Collections.some(this, f);
 }
 FixedCollection.prototype.isEmpty = function() {
   return this.length == 0;
 }
 FixedCollection.prototype.filter$1 = FixedCollection.prototype.filter;
 FixedCollection.prototype.isEmpty$0 = function() {
   return this.isEmpty();
@@ skipping 409 matching lines @@
 // ********** Code for ConstMapValue **************
 function ConstMapValue() {}
 ConstMapValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
   this.values = values;
   EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
   // Initializers done
 }
 ConstMapValue._internal$ctor.prototype = ConstMapValue.prototype;
 $inherits(ConstMapValue, EvaluatedValue);
 ConstMapValue.ConstMapValue$factory = function(type, keyValuePairs, actualValue, canonicalCode, span) {
-  var values = new HashMapImplementation$String$EvaluatedValue();
+  var values = new HashMapImplementation();
   for (var i = 0;
    i < keyValuePairs.length; i += 2) {
     values.$setindex(keyValuePairs.$index(i).get$actualValue(), keyValuePairs.$index(i + 1));
   }
   return new ConstMapValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 // ********** Code for ConstObjectValue **************
 function ConstObjectValue() {}
 ConstObjectValue._internal$ctor = function(type, fields, actualValue, canonicalCode, span, code) {
   this.fields = fields;
@@ skipping 1034 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 RunEntry(function () {main();}, []);