Fix method resolution to warn about things that don't exist on the declared type.

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 189 matching lines @@
 AssertError.prototype.toString = function() {
   return ("Failed assertion: '" + this.failedAssertion + "' is not true ") + ("in " + this.url + " at line " + this.line + ", column " + this.column + ".");
 }
 // ********** Code for Object **************
 Object.prototype.get$dynamic = function() {
   return this;
 }
 Object.prototype.noSuchMethod = function(name, args) {
   $throw(new NoSuchMethodException(this, name, args));
 }
-Object.prototype.forEach$1 = function($0) {
-  return this.noSuchMethod("forEach", [$0]);
-}
-;
 Object.prototype.get_$3 = function($0, $1, $2) {
   return this.noSuchMethod("get_", [$0, $1, $2]);
 }
 ;
 Object.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("invoke", [$0, $1, $2, $3]);
 }
 ;
 Object.prototype.printOn$1 = function($0) {
   return this.noSuchMethod("printOn", [$0]);
@@ skipping 644 matching lines @@
 }
 
 function _IsolateJsUtil() {}
 // ********** Code for ListFactory **************
 ListFactory = Array;
 ListFactory.prototype.is$List = function(){return this;};
 ListFactory.prototype.is$List$ArgumentNode = function(){return this;};
 ListFactory.prototype.is$List$EvaluatedValue = function(){return this;};
 ListFactory.prototype.is$List$String = function(){return this;};
 ListFactory.prototype.is$List$T = 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$Iterable = function(){return this;};
 ListFactory.ListFactory$from$factory = function(other) {
   var $0;
   var list = [];
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     list.add(e);
   }
@@ skipping 23 matching lines @@
 }
 ListFactory.prototype.getRange = function(start, length) {
   return this.slice(start, start + length);
 }
 ListFactory.prototype.isEmpty = function() {
   return this.length == 0;
 }
 ListFactory.prototype.iterator = function() {
   return new ListIterator(this);
 }
-ListFactory.prototype.forEach$1 = ListFactory.prototype.forEach;
 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;
@@ skipping 85 matching lines @@
 }
 // ********** Code for ImmutableMap **************
 function ImmutableMap(keyValuePairs) {
   this._internal = $map([]);
   // Initializers done
   for (var i = 0;
    $notnull_bool(i < keyValuePairs.length); i += 2) {
     this._internal.$setindex(keyValuePairs.$index(i), keyValuePairs.$index(i + 1));
   }
 }
-ImmutableMap.prototype.is$Map = 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", {
   get: ImmutableMap.prototype.get$length,
 });
 ImmutableMap.prototype.forEach = function(f) {
   this._internal.forEach(f);
 }
 ImmutableMap.prototype.getKeys = function() {
   return this._internal.getKeys();
 }
 ImmutableMap.prototype.getValues = function() {
   return this._internal.getValues();
 }
 ImmutableMap.prototype.containsKey = function(key) {
   return this._internal.containsKey(key);
 }
 ImmutableMap.prototype.$setindex = function(key, value) {
   $throw(const$221/*const IllegalAccessException()*/);
 }
-ImmutableMap.prototype.forEach$1 = ImmutableMap.prototype.forEach;
 // ********** Code for MatchImplementation **************
 function MatchImplementation(pattern, str, _start, _end, _groups) {
   this.pattern = pattern;
   this.str = str;
   this._start = _start;
   this._end = _end;
   this._groups = _groups;
   // Initializers done
 }
 MatchImplementation.prototype.$index = function(group) {
@@ skipping 64 matching lines @@
   // Initializers done
   if ($notnull_bool(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*/);
 }
-HashMapImplementation.prototype.is$Map = function(){return this;};
 HashMapImplementation.HashMapImplementation$from$factory = function(other) {
   var result = new HashMapImplementation();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
   })
   );
   return result;
 }
 HashMapImplementation._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
@@ skipping 140 matching lines @@
   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.forEach$1 = HashMapImplementation.prototype.forEach;
 // ********** Code for HashMapImplementation$E$E **************
 function HashMapImplementation$E$E() {
   // Initializers done
   if ($notnull_bool(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*/);
 }
 $inherits(HashMapImplementation$E$E, HashMapImplementation);
-HashMapImplementation$E$E.prototype.is$Map = 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);
 }
 HashMapImplementation$E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - 1);
 }
 HashMapImplementation$E$E.prototype._probeForAdding = function(key) {
@@ skipping 125 matching lines @@
   if ($notnull_bool(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*/);
 }
 $inherits(HashMapImplementation$Element$HInstruction, HashMapImplementation);
-HashMapImplementation$Element$HInstruction.prototype.is$Map = function(){return this;};
 HashMapImplementation$Element$HInstruction.HashMapImplementation$from$factory = function(other) {
   var result = new HashMapImplementation();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
   })
   );
   return result;
 }
 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 ($notnull_bool(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*/);
 }
 $inherits(HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V, HashMapImplementation);
-HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.is$Map = function(){return this;};
 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 ($notnull_bool(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 = function(){return this;};
 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 ($notnull_bool(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 = function(){return this;};
 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 ($notnull_bool(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*/);
 }
 $inherits(HashMapImplementation$String$EvaluatedValue, HashMapImplementation);
-HashMapImplementation$String$EvaluatedValue.prototype.is$Map = function(){return this;};
 HashMapImplementation$String$EvaluatedValue._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$String$String **************
 function HashMapImplementation$String$String() {
   // Initializers done
   if ($notnull_bool(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 = function(){return this;};
 HashMapImplementation$String$String._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$Type$Type **************
 function HashMapImplementation$Type$Type() {
   // Initializers done
   if ($notnull_bool(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 = function(){return this;};
 HashMapImplementation$Type$Type._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$int$int **************
 function HashMapImplementation$int$int() {
   // Initializers done
   if ($notnull_bool(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$int(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$int$int, HashMapImplementation);
-HashMapImplementation$int$int.prototype.is$Map = function(){return this;};
 HashMapImplementation$int$int._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
   // Initializers done
   this._backingMap = new HashMapImplementation$E$E();
 }
 HashSetImplementation.prototype.is$Iterable = function(){return this;};
 HashSetImplementation.HashSetImplementation$from$factory = function(other) {
@@ skipping 49 matching lines @@
 }
 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);
 }
-HashSetImplementation.prototype.forEach$1 = HashSetImplementation.prototype.forEach;
 // ********** Code for HashSetImplementation$E **************
 function HashSetImplementation$E() {
   // Initializers done
   this._backingMap = new HashMapImplementation$E$E();
 }
 $inherits(HashSetImplementation$E, HashSetImplementation);
 HashSetImplementation$E.prototype.is$Iterable = function(){return this;};
 // ********** Code for HashSetImplementation$String **************
 function HashSetImplementation$String() {
   // Initializers done
@@ skipping 85 matching lines @@
 $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._list = new DoubleLinkedQueue$KeyValuePair$K$V();
 }
-LinkedHashMapImplementation.prototype.is$Map = function(){return this;};
 LinkedHashMapImplementation.prototype.$setindex = function(key, value) {
   if ($notnull_bool(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) {
@@ skipping 33 matching lines @@
 }
 LinkedHashMapImplementation.prototype.get$length = function() {
   return this._map.get$length();
 }
 Object.defineProperty(LinkedHashMapImplementation.prototype, "length", {
   get: LinkedHashMapImplementation.prototype.get$length,
 });
 LinkedHashMapImplementation.prototype.isEmpty = function() {
   return this.get$length() == 0;
 }
-LinkedHashMapImplementation.prototype.forEach$1 = LinkedHashMapImplementation.prototype.forEach;
 // ********** 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();
 }
 $inherits(LinkedHashMapImplementation$Node$Element, LinkedHashMapImplementation);
-LinkedHashMapImplementation$Node$Element.prototype.is$Map = function(){return this;};
 // ********** 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();
 }
 $inherits(LinkedHashMapImplementation$String$Keyword, LinkedHashMapImplementation);
-LinkedHashMapImplementation$String$Keyword.prototype.is$Map = function(){return this;};
 // ********** 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) {
   this._next = n;
   this._previous = p;
   p._next = this;
@@ skipping 216 matching lines @@
   var entry = this._sentinel._next;
   while ($notnull_bool(entry !== this._sentinel)) {
     if ($notnull_bool(f(entry._element))) other.addLast(entry._element);
     entry = entry._next;
   }
   return other;
 }
 DoubleLinkedQueue.prototype.iterator = function() {
   return new _DoubleLinkedQueueIterator$E(this._sentinel);
 }
-DoubleLinkedQueue.prototype.forEach$1 = DoubleLinkedQueue.prototype.forEach;
 // ********** Code for DoubleLinkedQueue$E **************
 function DoubleLinkedQueue$E() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$E();
 }
 $inherits(DoubleLinkedQueue$E, DoubleLinkedQueue);
 DoubleLinkedQueue$E.prototype.is$Iterable = function(){return this;};
 // ********** Code for DoubleLinkedQueue$KeyValuePair$K$V **************
 function DoubleLinkedQueue$KeyValuePair$K$V() {
   // Initializers done
@@ skipping 4956 matching lines @@
 Literal.prototype.getEndToken = function() {
   return this.token;
 }
 // ********** Code for Literal$SourceString **************
 function Literal$SourceString(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
 }
 $inherits(Literal$SourceString, Literal);
-Literal$SourceString.prototype.hashCode = function() {
-  return this._hashCode;
-}
 // ********** Code for Literal$bool **************
 function Literal$bool(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
 }
 $inherits(Literal$bool, Literal);
-Literal$bool.prototype.hashCode = function() {
-  return this._hashCode;
-}
 // ********** Code for Literal$double **************
 function Literal$double(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
 }
 $inherits(Literal$double, Literal);
-Literal$double.prototype.hashCode = function() {
-  return this._hashCode;
-}
 // ********** Code for Literal$int **************
 function Literal$int(token, handler) {
   this.token = token;
   this.handler = handler;
   // Initializers done
 }
 $inherits(Literal$int, Literal);
-Literal$int.prototype.hashCode = function() {
-  return this._hashCode;
-}
 // ********** Code for LiteralInt **************
 function LiteralInt(token, handler) {
   Literal$int.call(this, token, handler);
   // Initializers done
 }
 $inherits(LiteralInt, Literal$int);
 LiteralInt.prototype.get$value = function() {
   try {
     return Math.parseInt($assert_String(this.token.get$value().toString()));
   } catch (ex) {
@@ skipping 3113 matching lines @@
 }
 WorldGenerator.prototype.writeType = function(type) {
   var $0;
   if ($notnull_bool(type.name != null && (type instanceof ConcreteType) && $eq(type.get$library(), world.get$coreimpl()) && type.name.startsWith('ListFactory'))) {
     this.writer.writeln(('' + type.get$jsname() + ' = ' + type.get$genericType().get$jsname() + ';'));
     return;
   }
   var typeName = $notnull_bool(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()))) {
-    var nativeName = type.get$definition().nativeType;
+    var nativeName = type.get$definition().get$nativeType();
     if ($notnull_bool($eq(nativeName, ''))) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
     else if ($notnull_bool(type.get$jsname() != nativeName)) {
       this.writer.writeln(('' + type.get$jsname() + ' = ' + nativeName + ';'));
     }
   }
   if ($notnull_bool(type.get$isTop())) {
   }
-  else if ($notnull_bool(type.constructors.get$length() == 0)) {
+  else if ($notnull_bool(type.get$constructors().get$length() == 0)) {
     if ($notnull_bool(!$notnull_bool(type.get$isNativeType()))) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
   }
   else {
-    var standardConstructor = (($0 = type.constructors.$index('')) && $0.is$Member());
+    var standardConstructor = (($0 = type.get$constructors().$index('')) && $0.is$Member());
     if ($notnull_bool(standardConstructor == null || standardConstructor.generator == null)) {
       if ($notnull_bool(!$notnull_bool(type.get$isNativeType()))) {
         this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
       }
     }
     else {
       standardConstructor.generator.writeDefinition(this.writer, null);
     }
-    var $list = type.constructors.getValues();
-    for (var $i = type.constructors.getValues().iterator(); $i.hasNext(); ) {
+    var $list = type.get$constructors().getValues();
+    for (var $i = type.get$constructors().getValues().iterator(); $i.hasNext(); ) {
       var c = $i.next();
       if ($notnull_bool($ne(c.generator, null) && $ne(c, standardConstructor))) {
         c.generator.writeDefinition(this.writer, null);
       }
     }
   }
   if ($notnull_bool(!$notnull_bool(type.get$isTop()))) {
     if ($notnull_bool((type instanceof ConcreteType))) {
       this._ensureInheritsHelper();
       this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$genericType().get$jsname() + ');'));
@@ skipping 33 matching lines @@
       var $list = interface_.get$interfaces();
       for (var $i = 0;$i < $list.length; $i++) {
         var other = $list.$index($i);
         if ($notnull_bool(!$notnull_bool(seen.contains(other)))) {
           worklist.addLast(other);
           seen.add(other);
         }
       }
     }
   }
-  type.factories.forEach$1(this.get$_writeMethod());
-  var $list = this._orderValues((($0 = type.members) && $0.is$Map()));
+  type.get$factories().forEach(this.get$_writeMethod());
+  var $list = this._orderValues(type.get$members());
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
     if ($notnull_bool((member instanceof FieldMember))) {
       this._writeField((member && member.is$FieldMember()));
     }
     if ($notnull_bool((member instanceof PropertyMember))) {
       this._writeProperty((member && member.is$PropertyMember()));
     }
     if ($notnull_bool(member.get$isMethod())) {
       this._writeMethod((member && member.is$Member()));
@@ skipping 75 matching lines @@
     var global = $i.next();
     if ($notnull_bool(global.field != null)) {
       this._writeStaticField(global.field);
     }
     else {
       this.writer.writeln(('var ' + global.get$name() + ' = ' + global.exp.code + ';'));
     }
   }
 }
 WorldGenerator.prototype._orderValues = function(map) {
-  var values = map.getValues();
+  var $0;
+  var values = (($0 = map.getValues()) && $0.is$List());
   values.sort(this.get$_compareMembers());
   return values;
 }
 WorldGenerator.prototype._compareMembers = function(x, y) {
   if ($notnull_bool(x.get$span() != null && y.get$span() != null)) {
     var spans = x.get$span().compareTo(y.get$span());
     if ($notnull_bool(spans != 0)) return spans;
   }
   if ($notnull_bool(x.get$span() == null)) return 1;
   if ($notnull_bool(y.get$span() == null)) return -1;
   return x.get$name().compareTo(y.get$name());
 }
 WorldGenerator.prototype.get$_compareMembers = function() {
   return WorldGenerator.prototype._compareMembers.bind(this);
 }
 WorldGenerator.prototype.useMapFactory = function() {
   var $0;
   this.corejs.useMap = true;
   var factType = world.get$coreimpl().types.$index('HashMapImplementation');
   var m = factType.resolveMember('\$setindex');
-  this.genMethod((($0 = m.members.$index(0)) && $0.is$Member()));
+  this.genMethod((($0 = m.get$members().$index(0)) && $0.is$Member()));
   var c = factType.getConstructor('');
   this.genMethod((c && c.is$Member()));
   return factType;
 }
 // ********** Code for BlockScope **************
 function BlockScope(enclosingMethod, parent, reentrant) {
   this.enclosingMethod = enclosingMethod;
   this.parent = parent;
   this.reentrant = reentrant;
   this._vars = $map([]);
@@ skipping 86 matching lines @@
   this.needsThis = false;
   // Initializers done
   if ($notnull_bool(this.enclosingMethod != null)) {
     this._scope = new BlockScope(this, this.enclosingMethod._scope, false);
     this.captures = new HashSetImplementation();
   }
   else {
     this._scope = new BlockScope(this, null, false);
   }
   if ($notnull_bool(this.enclosingMethod != null && this.method.name != '')) {
-    this._scope.create(this.method.name, this.method.get$functionType(), (($0 = this.method.get$definition()) && $0.is$lang_Node()), false);
+    var m = (($0 = this.method) && $0.is$MethodMember());
+    this._scope.create(m.name, m.get$functionType(), m.definition, false);
   }
   this._usedTemps = new HashSetImplementation();
   this._freeTemps = [];
 }
 MethodGenerator.prototype.is$MethodGenerator = function(){return this;};
 MethodGenerator.prototype.findMembers = function(name) {
   return this.method.get$library()._findMembers(name);
 }
 MethodGenerator.prototype.get$isClosure = function() {
   return (this.enclosingMethod != null);
@@ skipping 45 matching lines @@
       })
       );
       this.writer.write($assert_String(this.method.get$definition().body.body));
     }
   }
   else {
     this.writeBody();
   }
 }
 MethodGenerator.prototype.writeDefinition = function(defWriter, lambda) {
+  var $0;
   var paramCode = this._paramCode;
   var names = null;
   if ($notnull_bool(this.captures != null && this.captures.get$length() > 0)) {
     names = ListFactory.ListFactory$from$factory(this.captures);
     names.sort((function (x, y) {
       return x.compareTo(y);
     })
     );
     paramCode = ListFactory.ListFactory$from$factory((names && names.is$Iterable()));
     paramCode.addAll(this._paramCode);
@@ skipping 33 matching lines @@
   else if ($notnull_bool(this.method.get$isStatic())) {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   else {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.prototype.') + ('' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   if ($notnull_bool(this.needsThis)) {
     defWriter.writeln('var \$this = this; // closure support');
   }
   if ($notnull_bool(this._usedTemps.get$length() > 0 || this._freeTemps.length > 0)) {
-    $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 693, 14);
+    $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 694, 14);
     this._freeTemps.addAll(this._usedTemps);
     this._freeTemps.sort((function (x, y) {
       return x.compareTo(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()), ", ") + ')'));
   }
   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;'));
   }
   this._provideOptionalParamInfo(defWriter);
-  if ($notnull_bool((this.method instanceof MethodMember) && this.method._providePropertySyntax)) {
-    defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.prototype.get\$' + this.method.get$jsname() + ' = function() {'));
-    defWriter.writeln(('return ' + this.method.declaringType.get$jsname() + '.prototype.' + this.method.get$jsname() + '.bind(this);'));
-    defWriter.exitBlock('}');
-    if ($notnull_bool(this.method._provideFieldSyntax)) {
-      world.internalError('bound method accessed with field syntax');
+  if ($notnull_bool((this.method instanceof MethodMember))) {
+    var m = (($0 = this.method) && $0.is$MethodMember());
+    if ($notnull_bool(m._providePropertySyntax)) {
+      defWriter.enterBlock(('' + m.declaringType.get$jsname() + '.prototype') + ('.get\$' + m.get$jsname() + ' = function() {'));
+      defWriter.writeln(('return ' + m.declaringType.get$jsname() + '.prototype.') + ('' + m.get$jsname() + '.bind(this);'));
+      defWriter.exitBlock('}');
+      if ($notnull_bool(m._provideFieldSyntax)) {
+        world.internalError('bound m accessed with field syntax');
+      }
     }
   }
 }
 MethodGenerator.prototype._provideOptionalParamInfo = function(defWriter) {
-  if ($notnull_bool((this.method instanceof MethodMember) && this.method._provideOptionalParamInfo)) {
-    var optNames = [];
-    var optValues = [];
-    this.method.genParameterValues();
-    var $list = this.method.get$parameters();
-    for (var $i = 0;$i < $list.length; $i++) {
-      var param = $list.$index($i);
-      if ($notnull_bool(param.get$isOptional())) {
-        optNames.add(param.get$name());
-        optValues.add(MethodGenerator._escapeString(param.get$value().code));
-      }
-    }
-    if ($notnull_bool(optNames.length > 0)) {
-      var start = '';
-      if ($notnull_bool(this.method.get$isStatic())) {
-        if ($notnull_bool(!$notnull_bool(this.method.declaringType.get$isTop()))) {
-          start = this.method.declaringType.get$jsname() + '.';
+  var $0;
+  if ($notnull_bool((this.method instanceof MethodMember))) {
+    var meth = (($0 = this.method) && $0.is$MethodMember());
+    if ($notnull_bool(meth._provideOptionalParamInfo)) {
+      var optNames = [];
+      var optValues = [];
+      meth.genParameterValues();
+      var $list = meth.parameters;
+      for (var $i = 0;$i < $list.length; $i++) {
+        var param = $list.$index($i);
+        if ($notnull_bool(param.get$isOptional())) {
+          optNames.add(param.get$name());
+          optValues.add(MethodGenerator._escapeString(param.get$value().code));
         }
       }
-      else {
-        start = this.method.declaringType.get$jsname() + '.prototype.';
+      if ($notnull_bool(optNames.length > 0)) {
+        var start = '';
+        if ($notnull_bool(meth.isStatic)) {
+          if ($notnull_bool(!$notnull_bool(meth.declaringType.get$isTop()))) {
+            start = meth.declaringType.get$jsname() + '.';
+          }
+        }
+        else {
+          start = meth.declaringType.get$jsname() + '.prototype.';
+        }
+        optNames.addAll(optValues);
+        var optional = "['" + Strings.join((optNames && optNames.is$List$String()), "', '") + "']";
+        defWriter.writeln(('' + start + '' + meth.get$jsname() + '.\$optional = ' + optional + ''));
       }
-      optNames.addAll(optValues);
-      var optional = "['" + Strings.join((optNames && optNames.is$List$String()), "', '") + "']";
-      defWriter.writeln(('' + start + '' + this.method.get$jsname() + '.\$optional = ' + optional + ''));
     }
   }
 }
 MethodGenerator.prototype.writeBody = function() {
   var $0;
   var initializers = null;
   var initializedFields = null;
   if ($notnull_bool(this.method.get$isConstructor())) {
     initializers = [];
     initializedFields = new HashSetImplementation();
@@ skipping 84 matching lines @@
           }
           initializedFields = null;
         }
       }
       else {
       }
     }
     this.writer.comment('// Initializers done');
   }
   if ($notnull_bool($ne(initializedFields, null))) {
-    var $list = this.method.declaringType.members.getKeys();
-    for (var $i = this.method.declaringType.members.getKeys().iterator(); $i.hasNext(); ) {
+    var $list = this.method.declaringType.get$members().getKeys();
+    for (var $i = this.method.declaringType.get$members().getKeys().iterator(); $i.hasNext(); ) {
       var name = $i.next();
-      var member = this.method.declaringType.members.$index(name);
+      var member = this.method.declaringType.get$members().$index(name);
       if ($notnull_bool((member instanceof FieldMember) && member.isFinal && !$notnull_bool(member.get$isStatic()) && !$notnull_bool(initializedFields.contains(name)))) {
         world.error(('Field "' + name + '" is final and was not initialized'), this.method.get$definition().get$span());
       }
     }
   }
   this.visitStatementsInBlock((body && body.is$lang_Statement()));
 }
 MethodGenerator.prototype._writeInitializerCall = function(node) {
   var contructorName = '';
   var targetExp = node.target;
@@ skipping 42 matching lines @@
       world.error('bare argument can not follow named arguments', arg.get$span());
     }
     args.add(this.visitValue((($0 = arg.get$value()) && $0.is$lang_Expression())));
   }
   return new Arguments(arguments, args);
 }
 MethodGenerator._escapeString = function(text) {
   return text.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('\n', '\\n').replaceAll('\r', '\\r');
 }
 MethodGenerator.prototype.visitStatementsInBlock = function(body) {
-  var $0;
   if ($notnull_bool((body instanceof BlockStatement))) {
-    var $list = body.body;
-    for (var $i = body.body.iterator(); $i.hasNext(); ) {
-      var stmt = $i.next();
+    var block = (body && body.is$BlockStatement());
+    var $list = block.body;
+    for (var $i = 0;$i < $list.length; $i++) {
+      var stmt = $list.$index($i);
       stmt.visit(this);
     }
   }
   else {
     if ($notnull_bool(body != null)) body.visit(this);
   }
   return false;
 }
 MethodGenerator.prototype._pushBlock = function(reentrant) {
   this._scope = new BlockScope(this, this._scope, reentrant);
@@ skipping 67 matching lines @@
       this.writer.write(('' + val.code + ' = ' + value.code + ''));
     }
   }
   this.writer.writeln(';');
   return false;
 }
 MethodGenerator.prototype.visitFunctionDefinition = function(node) {
   var $0;
   var name = world.toJsIdentifier(node.name.name);
   var meth = this._makeLambdaMethod($assert_String(name), node);
-  var funcValue = this._scope.create($assert_String(name), meth.get$functionType(), (($0 = this.method.get$definition()) && $0.is$lang_Node()), false);
+  var funcValue = this._scope.create($assert_String(name), (($0 = meth.get$functionType()) && $0.is$lang_Type()), (($0 = this.method.get$definition()) && $0.is$lang_Node()), false);
   meth.generator.writeDefinition(this.writer, null);
   return false;
 }
 MethodGenerator.prototype.visitReturnStatement = function(node) {
   if ($notnull_bool(node.value == null)) {
     this.writer.writeln('return;');
   }
   else {
     if ($notnull_bool(this.method.get$isConstructor())) {
       world.error('return of value not allowed from constructor', node.span);
@@ skipping 19 matching lines @@
     }
   }
   return true;
 }
 MethodGenerator.prototype.visitAssertStatement = function(node) {
   var $0;
   var test = this.visitValue(node.test);
   if ($notnull_bool(options.enableAsserts)) {
     var err = world.corelib.types.$index('AssertError');
     world.gen.genMethod((($0 = err.getConstructor('')) && $0.is$Member()));
-    world.gen.genMethod((($0 = err.members.$index('toString')) && $0.is$Member()));
+    world.gen.genMethod((($0 = err.get$members().$index('toString')) && $0.is$Member()));
     var span = node.test.span;
     var line = span.file.getLine(span.start);
     var column = span.file.getColumn($assert_num(line), span.start);
     this.writer.writeln(('\$assert(' + test.code + ', "' + MethodGenerator._escapeString(span.get$text()) + '",') + (' "' + basename(span.file.filename) + '", ' + (line + 1) + ', ' + (column + 1) + ');'));
     world.gen.corejs.useAssert = true;
   }
   return false;
 }
 MethodGenerator.prototype.visitBreakStatement = function(node) {
   if ($notnull_bool(node.label == null)) {
@@ skipping 106 matching lines @@
 }
 MethodGenerator.prototype._genToDartException = function(ex, node) {
   var $0;
   var types = const$390/*const [
         'NullPointerException', 'ObjectNotClosureException',
         'NoSuchMethodException', 'StackOverflowException']*/;
   var target = new Value(null, 'this', false, true, false);
   for (var $i = types.iterator(); $i.hasNext(); ) {
     var name = $i.next();
     world.corelib.types.$index(name).markUsed();
-    world.corelib.types.$index(name).members.$index('toString').invoke$4(this, node, target, Arguments.get$EMPTY());
+    world.corelib.types.$index(name).get$members().$index('toString').invoke$4(this, node, target, Arguments.get$EMPTY());
   }
   this.writer.writeln(('' + ex + ' = \$toDartException(' + ex + ');'));
   world.gen.corejs.useToDartException = true;
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
   var $0;
   this.writer.enterBlock('try {');
   this._pushBlock(false);
   this.visitStatementsInBlock(node.body);
   this._popBlock();
@@ skipping 192 matching lines @@
   var name = '';
   if ($notnull_bool(node.func.name != null)) {
     name = world.toJsIdentifier(node.func.name.name);
   }
   var meth = this._makeLambdaMethod($assert_String(name), node.func);
   var w = new CodeWriter();
   meth.generator.writeDefinition((w && w.is$CodeWriter()), node);
   return new Value(meth.get$functionType(), w.get$text(), false, true, false);
 }
 MethodGenerator.prototype.visitCallExpression = function(node) {
+  var $0;
   var target;
   var position = node.target;
   var name = '\$call';
   if ($notnull_bool((node.target instanceof DotExpression))) {
-    target = node.target.self.visit(this);
-    name = node.target.get$name().get$name();
-    position = node.target.get$name();
+    var dot = (($0 = node.target) && $0.is$DotExpression());
+    target = dot.self.visit(this);
+    name = dot.name.name;
+    position = dot.name;
   }
   else if ($notnull_bool((node.target instanceof VarExpression))) {
-    name = node.target.get$name().get$name();
+    var varExpr = (($0 = node.target) && $0.is$VarExpression());
+    name = varExpr.name.name;
     var meth = this.method.declaringType.resolveMember(name);
     if ($notnull_bool($ne(meth, null))) {
       target = this._makeThisOrType();
-      return meth.invoke$4(this, node.target, target, this._makeArgs(node.arguments));
+      return meth.invoke$4(this, varExpr, target, this._makeArgs(node.arguments));
     }
-    meth = this.method.declaringType.get$library().lookup($assert_String(name), node.target.span);
+    meth = this.method.declaringType.get$library().lookup($assert_String(name), varExpr.span);
     if ($notnull_bool($ne(meth, null))) {
-      return meth.invoke$4(this, node.target, null, this._makeArgs(node.arguments));
+      return meth.invoke$4(this, varExpr, null, this._makeArgs(node.arguments));
     }
     name = '\$call';
-    target = node.target.visit(this);
+    target = varExpr.visit(this);
   }
   else {
     target = node.target.visit(this);
   }
   return target.invoke$4(this, name, position, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitIndexExpression = function(node) {
   var target = this.visitValue(node.target);
   var index = this.visitValue(node.index);
   return target.invoke$4(this, '\$index', node, new Arguments(null, [index]));
@@ skipping 389 matching lines @@
 }
 MethodGenerator.prototype.visitSuperExpression = function(node) {
   return this._makeSuperValue(node);
 }
 MethodGenerator.prototype.visitNullExpression = function(node) {
   return EvaluatedValue.EvaluatedValue$factory(null, null, 'null', null);
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   var $0;
   var type = node.type.type;
-  $assert($ne(type, null), "type != null", "gen.dart", 2063, 12);
+  $assert($ne(type, null), "type != null", "gen.dart", 2072, 12);
   if ($notnull_bool(!!(($0 = node.value) && $0.is$List))) {
     var items = [];
     var $list = node.value;
     for (var $i = node.value.iterator(); $i.hasNext(); ) {
       var item = $i.next();
       var val = this.visitValue((item && item.is$lang_Expression()));
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
       var code = val.code;
       if ($notnull_bool((item instanceof BinaryExpression) || (item instanceof ConditionalExpression))) {
         code = ('(' + code + ')');
@@ skipping 203 matching lines @@
         var lib = $i.next();
         if ($notnull_bool(lib._privateMembers.containsKey(member.name))) {
           member.set$jsname(('_' + this.get$jsname() + '' + member.name + ''));
           break;
         }
       }
       mset = new MemberSet(member);
       this._privateMembers.$setindex(member.name, mset);
     }
     else {
-      mset.members.add(member);
+      mset.get$members().add(member);
     }
   }
   else {
     world._addMember(member);
   }
 }
 Library.prototype.getOrAddFunctionType = function(name, func, inType) {
   var def = new FunctionTypeDefinition(func, null, func.span);
   var type = new DefinedType(name, this, def, false);
   type.addMethod('\$call', func);
@@ skipping 286 matching lines @@
   return parseStringLiteral($assert_String(expr.get$value()));
 }
 _LibraryVisitor.prototype.visitTypeDefinition = function(node) {
   var oldType = this.currentType;
   this.currentType = this.library.addType(node.name.name, node, node.isClass);
   var $list = node.body;
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
     member.visit(this);
   }
-  this.currentType = (oldType && oldType.is$lang_Type());
+  this.currentType = (oldType && oldType.is$DefinedType());
 }
 _LibraryVisitor.prototype.visitVariableDefinition = function(node) {
   this.currentType.addField(node);
 }
 _LibraryVisitor.prototype.visitFunctionDefinition = function(node) {
   this.currentType.addMethod(node.name.name, node);
 }
 _LibraryVisitor.prototype.visitFunctionTypeDefinition = function(node) {
   var type = this.library.addType(node.func.name.name, node, false);
   type.addMethod('\$call', node.func);
@@ skipping 85 matching lines @@
 }
 Member.prototype.get$isMethod = function() {
   return false;
 }
 Member.prototype.get$isProperty = function() {
   return false;
 }
 Member.prototype.get$isAbstract = function() {
   return false;
 }
+Member.prototype.get$isConst = function() {
+  return false;
+}
+Member.prototype.get$isFactory = function() {
+  return false;
+}
 Member.prototype.get$prefersPropertySyntax = function() {
   return true;
 }
 Member.prototype.get$requiresFieldSyntax = function() {
   return false;
 }
 Member.prototype.get$isNative = function() {
   return false;
 }
 Member.prototype.get$constructorName = function() {
   return world.internalError('can not be a constructor', this.get$span());
 }
 Member.prototype.provideFieldSyntax = function() {
   return world.internalError('can not be field', this.get$span());
 }
 Member.prototype.providePropertySyntax = function() {
   return world.internalError('can not be property', this.get$span());
 }
+Member.prototype.get$initDelegate = function() {
+  return world.internalError('cannot have initializers', this.get$span());
+}
+Member.prototype.set$initDelegate = function(ctor) {
+  return world.internalError('cannot have initializers', this.get$span());
+}
 Member.prototype.get$definition = function() {
   return null;
 }
 Member.prototype.get$parameters = function() {
   return [];
 }
 Member.prototype.canInvoke = function(context, args) {
   return this.get$canGet() && new Value(this.get$returnType(), null, false, true, false).canInvoke(context, '\$call', args);
 }
 Member.prototype.invoke = function(context, node, target, args, isDynamic) {
   var newTarget = this.get_(context, node, target, isDynamic);
   return newTarget.invoke(context, '\$call', node, args, isDynamic);
 }
 Member.prototype.override = function(other) {
   if ($notnull_bool(this.get$isStatic())) {
     world.error('static members can not hide parent members', this.get$span(), other.get$span());
     return false;
   }
   else if ($notnull_bool(other.get$isStatic())) {
     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", 164, 12);
+  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 174, 12);
   var prefix = ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$');
   if ($notnull_bool(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() && type.get$hasTypeParams())) {
+    world.error('using type parameter in static context', node.span);
+  }
+  return type;
+}
 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.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.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()));
 }
 ;
 // ********** Code for TypeMember **************
 function TypeMember(type) {
   this.type = type;
   Member.call(this, type.name, type.library.topType);
   // Initializers done
 }
 $inherits(TypeMember, Member);
 TypeMember.prototype.get$span = function() {
   return this.type.definition.span;
 }
 TypeMember.prototype.get$isStatic = function() {
   return true;
 }
 TypeMember.prototype.get$returnType = function() {
-  return world.get$isVar();
+  return 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) {
-  $assert(target == null || target.type.get$isTop(), "target == null || target.type.isTop", "member.dart", 202, 12);
+  $assert(target == null || target.type.get$isTop(), "target == null || target.type.isTop", "member.dart", 222, 12);
   return new Value(this.type, this.type.get$jsname(), false, false, true);
 }
 TypeMember.prototype.set_ = function(context, node, target, value, isDynamic) {
   world.error('can not set type', this.type.definition.span);
 }
 TypeMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   world.error('can not invoke type', this.type.definition.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);
@@ skipping 133 matching lines @@
       return cv;
     }
     if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.type, ('' + this.get$jsname() + ''), false, true, false);
     }
     else {
       return new Value(this.type, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + ''), false, true, false);
     }
   }
   else if ($notnull_bool(target.get$isConst() && this.isFinal)) {
-    var constTarget = $notnull_bool((target instanceof GlobalValue)) ? target.exp : target;
+    var constTarget = $notnull_bool((target instanceof GlobalValue)) ? target.get$dynamic().exp : target;
     if ($notnull_bool((constTarget instanceof ConstObjectValue))) {
       return constTarget.fields.$index(this.name);
     }
     else if ($notnull_bool($eq(constTarget.type, world.stringType) && this.name == 'length')) {
       return new Value(this.type, ('' + constTarget.get$actualValue().length + ''), false, true, false);
     }
   }
   return new Value(this.type, ('' + target.code + '.' + this.get$jsname() + ''), false, true, false);
 }
 FieldMember.prototype.set_ = function(context, node, target, value, isDynamic) {
@@ skipping 71 matching lines @@
 PropertyMember.prototype.set_ = function(context, node, target, value, isDynamic) {
   if ($notnull_bool(this.setter == null)) {
     if ($notnull_bool(this._overriddenField != null)) {
       return this._overriddenField.set_(context, node, target, value, isDynamic);
     }
     return target.invokeNoSuchMethod(context, ('set:' + this.name + ''), node, new Arguments(null, [value]));
   }
   return this.setter.invoke(context, node, target, new Arguments(null, [value]), isDynamic);
 }
 PropertyMember.prototype.addFromParent = function(parentMember) {
+  var $0;
+  var parent;
   if ($notnull_bool((parentMember instanceof ConcreteMember))) {
-    parentMember = parentMember.baseMember;
+    var c = (parentMember && parentMember.is$ConcreteMember());
+    parent = (($0 = c.baseMember) && $0.is$PropertyMember());
   }
-  if ($notnull_bool(this.getter == null)) this.getter = parentMember.getter;
-  if ($notnull_bool(this.setter == null)) this.setter = parentMember.setter;
+  else {
+    parent = (parentMember && parentMember.is$PropertyMember());
+  }
+  if ($notnull_bool(this.getter == null)) this.getter = parent.getter;
+  if ($notnull_bool(this.setter == null)) this.setter = parent.setter;
 }
 PropertyMember.prototype.resolve = function(inType) {
   if ($notnull_bool(this.getter != null)) this.getter.resolve(inType);
   if ($notnull_bool(this.setter != null)) this.setter.resolve(inType);
   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);
 }
 ;
@@ skipping 14 matching lines @@
     var newType = p.type.resolveTypeParams(declaringType);
     if ($notnull_bool($ne(newType, p.type))) {
       this.parameters.add(p.copyWithNewType((newType && newType.is$lang_Type())));
     }
     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; };
 ConcreteMember.prototype.get$parameters = function() { return this.parameters; };
 ConcreteMember.prototype.set$parameters = function(value) { return this.parameters = value; };
 ConcreteMember.prototype.get$span = function() {
   return this.baseMember.get$span();
 }
 ConcreteMember.prototype.get$isStatic = function() {
   return this.baseMember.get$isStatic();
 }
 ConcreteMember.prototype.get$isAbstract = function() {
   return this.baseMember.get$isAbstract();
 }
 ConcreteMember.prototype.get$isConst = function() {
   return this.baseMember.get$isConst();
 }
+ConcreteMember.prototype.get$isFactory = function() {
+  return this.baseMember.get$isFactory();
+}
 ConcreteMember.prototype.get$jsname = function() {
   return this.baseMember.get$jsname();
 }
 ConcreteMember.prototype.set$jsname = function(name) {
   return world.internalError('bad set of jsname on ConcreteMember');
 }
-ConcreteMember.prototype.get$isFactory = function() {
-  return this.baseMember.get$isFactory();
-}
 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 112 matching lines @@
 MethodMember.prototype.get$canGet = function() {
   return false;
 }
 MethodMember.prototype.get$canSet = function() {
   return false;
 }
 MethodMember.prototype.get$span = function() {
   return $notnull_bool(this.definition == null) ? null : this.definition.span;
 }
 MethodMember.prototype.get$constructorName = function() {
-  if ($notnull_bool(this.definition.returnType == null)) return '';
-  if ($notnull_bool(this.definition.returnType.names != null)) {
-    return this.definition.returnType.names.$index(0).get$name();
+  var $0;
+  var returnType = (($0 = this.definition.returnType) && $0.is$NameTypeReference());
+  if ($notnull_bool(returnType == null)) return '';
+  if ($notnull_bool(returnType.names != null)) {
+    return returnType.names.$index(0).get$name();
   }
-  else if ($notnull_bool($ne(this.definition.returnType.get$name(), null))) {
-    return this.definition.returnType.get$name().get$name();
+  else if ($notnull_bool(returnType.name != null)) {
+    return returnType.name.name;
   }
   world.internalError('no valid constructor name', this.definition.span);
 }
 MethodMember.prototype.get$functionType = function() {
   if ($notnull_bool(this._functionType == null)) {
     this._functionType = this.get$library().getOrAddFunctionType(this.name, this.definition, this.declaringType);
     if ($notnull_bool(this.parameters == null)) {
       this.resolve(this.declaringType);
     }
   }
@@ skipping 29 matching lines @@
 MethodMember.prototype.indexOfParameter = function(name) {
   for (var i = 0;
    $notnull_bool(i < this.parameters.length); i++) {
     var p = this.parameters.$index(i);
     if ($notnull_bool(p.get$isOptional() && $eq(p.get$name(), name))) {
       return i;
     }
   }
   return -1;
 }
-MethodMember.prototype.resolveType = function(node, isRequired) {
-  var type = this.declaringType.resolveType(node, isRequired);
-  if ($notnull_bool(this.isStatic && type.get$hasTypeParams())) {
-    world.error('using type parameter in static context', node.span);
-  }
-  return type;
-}
 MethodMember.prototype.get$prefersPropertySyntax = function() {
   return true;
 }
 MethodMember.prototype.get$requiresFieldSyntax = function() {
   return false;
 }
 MethodMember.prototype.provideFieldSyntax = function() {
   return this._provideFieldSyntax = true;
 }
 MethodMember.prototype.providePropertySyntax = function() {
@@ skipping 158 matching lines @@
   }
   if ($notnull_bool(this.isStatic)) {
     if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.returnType, ('' + this.get$jsname() + '(' + argsString + ')'), false, true, false);
     }
     return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), false, true, false);
   }
   var code = ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')');
   if ($notnull_bool(target.get$isConst())) {
     if ($notnull_bool((target instanceof GlobalValue))) {
-      target = target.exp;
+      target = target.get$dynamic().exp;
     }
     if ($notnull_bool(this.name == 'get\$length')) {
       if ($notnull_bool((target instanceof ConstListValue) || (target instanceof ConstMapValue))) {
-        code = ('' + target.values.length + '');
+        code = ('' + target.get$dynamic().values.length + '');
       }
     }
     else if ($notnull_bool(this.name == 'isEmpty')) {
       if ($notnull_bool((target instanceof ConstListValue) || (target instanceof ConstMapValue))) {
-        code = ('' + target.values.isEmpty() + '');
+        code = ('' + target.get$dynamic().values.isEmpty() + '');
       }
     }
   }
   if ($notnull_bool(this.name == 'get\$typeName' && $eq(this.declaringType.get$library(), world.get$dom()))) {
     world.gen.corejs.useTypeNameOf = true;
   }
   return new Value(this.returnType, code, false, true, false);
 }
 MethodMember.prototype._invokeConstructor = function(context, node, target, args, argsString) {
   this.declaringType.markUsed();
   if ($notnull_bool(target != null)) {
     var code = $notnull_bool((this.get$constructorName() != '')) ? ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor.call(' + argsString + ')') : ('' + this.declaringType.get$jsname() + '.call(' + argsString + ')');
     return new Value(this.declaringType, code, false, true, false);
   }
   else {
     var code = $notnull_bool((this.get$constructorName() != '')) ? ('new ' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor(' + argsString + ')') : ('new ' + this.declaringType.get$jsname() + '(' + argsString + ')');
-    if ($notnull_bool(this.isConst && node.get$isConst())) {
+    if ($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, false, true, false);
     }
   }
 }
 MethodMember.prototype._invokeConstConstructor = function(node, code, target, args) {
   var $0;
   var fields = new HashMapImplementation$String$EvaluatedValue();
@@ skipping 45 matching lines @@
             value = value.exp;
           }
           var $list0 = value.fields.getKeys();
           for (var $i0 = value.fields.getKeys().iterator(); $i0.hasNext(); ) {
             var fname = $i0.next();
             fields.$setindex(fname, value.fields.$index(fname));
           }
         }
       }
       else {
-        var fname = init.x.get$name().get$name();
-        var val = this.generator.visitValue(init.y);
+        var assign = (init && init.is$BinaryExpression());
+        var x = (($0 = assign.x) && $0.is$VarExpression());
+        var fname = x.name.name;
+        var val = this.generator.visitValue(assign.y);
         fields.$setindex(fname, val);
       }
     }
     this.generator._popBlock();
   }
-  var $list = this.declaringType.members.getValues();
-  for (var $i = this.declaringType.members.getValues().iterator(); $i.hasNext(); ) {
+  var $list = this.declaringType.get$members().getValues();
+  for (var $i = this.declaringType.get$members().getValues().iterator(); $i.hasNext(); ) {
     var f = $i.next();
     if ($notnull_bool((f instanceof FieldMember) && !$notnull_bool(f.get$isStatic()) && $ne(f.get$value(), null) && !$notnull_bool(fields.containsKey(f.get$name())))) {
       fields.$setindex(f.get$name(), f.computeValue());
     }
   }
   return world.gen.globalForConst(ConstObjectValue.ConstObjectValue$factory(this.declaringType, fields, code, node.span), args.values);
 }
 MethodMember.prototype._invokeBuiltin = function(context, node, target, args, argsCode) {
   var allConst = target.get$isConst() && args.values.every((function (arg) {
     return arg.get$isConst();
@@ skipping 287 matching lines @@
 ;
 // ********** Code for MemberSet **************
 function MemberSet(member) {
   this.name = member.name;
   this.members = [member];
   this.jsname = member.get$jsname();
   // Initializers done
 }
 MemberSet.prototype.is$MemberSet = function(){return this;};
 MemberSet.prototype.get$name = function() { return this.name; };
+MemberSet.prototype.get$members = function() { return this.members; };
 MemberSet.prototype.get$jsname = function() { return this.jsname; };
 MemberSet.prototype.toString = function() {
   return ('' + this.name + ':' + this.members.length + '');
 }
 MemberSet.prototype.get$containsMethods = function() {
   return this.members.some((function (m) {
     return (m instanceof MethodMember);
   })
   );
 }
@@ skipping 210 matching lines @@
 }
 FactoryMap.prototype.forEach = function(f) {
   this.factories.forEach((function (_, constructors) {
     constructors.forEach((function (_, member) {
       f(member);
     })
     );
   })
   );
 }
-FactoryMap.prototype.forEach$1 = FactoryMap.prototype.forEach;
 // ********** 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$source = function() { return this.source; };
 lang_Token.prototype.get$text = function() {
@@ skipping 3357 matching lines @@
 // ********** Code for Definition **************
 function Definition(span) {
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(Definition, lang_Statement);
 Definition.prototype.is$Definition = function(){return this;};
 Definition.prototype.get$typeParameters = function() {
   return null;
 }
+Definition.prototype.get$nativeType = function() {
+  return null;
+}
 // ********** Code for lang_Statement **************
 function lang_Statement(span) {
   lang_Node.call(this, span);
   // Initializers done
 }
 $inherits(lang_Statement, lang_Node);
 lang_Statement.prototype.is$lang_Statement = function(){return this;};
 // ********** Code for lang_Expression **************
 function lang_Expression(span) {
   lang_Node.call(this, span);
@@ skipping 34 matching lines @@
   this.typeParameters = typeParameters;
   this.extendsTypes = extendsTypes;
   this.implementsTypes = implementsTypes;
   this.nativeType = nativeType;
   this.factoryType = factoryType;
   this.body = body;
   Definition.call(this, span);
   // Initializers done
 }
 $inherits(TypeDefinition, Definition);
+TypeDefinition.prototype.is$TypeDefinition = function(){return this;};
 TypeDefinition.prototype.get$isClass = function() { return this.isClass; };
 TypeDefinition.prototype.set$isClass = function(value) { return this.isClass = value; };
 TypeDefinition.prototype.get$name = function() { return this.name; };
 TypeDefinition.prototype.set$name = function(value) { return this.name = value; };
 TypeDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
 TypeDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
+TypeDefinition.prototype.get$nativeType = function() { return this.nativeType; };
+TypeDefinition.prototype.set$nativeType = function(value) { return this.nativeType = value; };
 TypeDefinition.prototype.visit = function(visitor) {
   return visitor.visitTypeDefinition(this);
 }
 // ********** Code for FunctionTypeDefinition **************
 function FunctionTypeDefinition(func, typeParameters, span) {
   this.func = func;
   this.typeParameters = typeParameters;
   Definition.call(this, span);
   // Initializers done
 }
@@ skipping 172 matching lines @@
 SwitchStatement.prototype.visit = function(visitor) {
   return visitor.visitSwitchStatement(this);
 }
 // ********** Code for BlockStatement **************
 function BlockStatement(body, span) {
   this.body = body;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(BlockStatement, lang_Statement);
+BlockStatement.prototype.is$BlockStatement = function(){return this;};
 BlockStatement.prototype.visit = function(visitor) {
   return visitor.visitBlockStatement(this);
 }
 // ********** Code for LabeledStatement **************
 function LabeledStatement(name, body, span) {
   this.name = name;
   this.body = body;
   lang_Statement.call(this, span);
   // Initializers done
 }
@@ skipping 293 matching lines @@
   return visitor.visitGenericTypeReference(this);
 }
 // ********** Code for FunctionTypeReference **************
 function FunctionTypeReference(isFinal, func, span) {
   this.isFinal = isFinal;
   this.func = func;
   TypeReference.call(this, span);
   // Initializers done
 }
 $inherits(FunctionTypeReference, TypeReference);
+FunctionTypeReference.prototype.is$FunctionTypeReference = function(){return this;};
 FunctionTypeReference.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeReference(this);
 }
 // ********** Code for ArgumentNode **************
 function ArgumentNode(label, value, span) {
   this.label = label;
   this.value = value;
   lang_Node.call(this, span);
   // Initializers done
 }
@@ skipping 161 matching lines @@
 }
 lang_Type.prototype.get$typeofName = function() {
   return null;
 }
 lang_Type.prototype.get$jsname = function() {
   return $notnull_bool(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;
 }
 lang_Type.prototype.get$interfaces = function() {
   return null;
 }
 lang_Type.prototype.get$parent = function() {
@@ skipping 113 matching lines @@
 ParameterType.prototype.is$ParameterType = function(){return this;};
 ParameterType.prototype.get$isClass = function() {
   return false;
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
 ParameterType.prototype.get$span = function() {
   return this.typeParameter.span;
 }
+ParameterType.prototype.get$constructors = function() {
+  return world.internalError('no constructors on type parameters yet');
+}
 ParameterType.prototype.getCallMethod = function() {
   return this.extendsType.getCallMethod();
 }
 ParameterType.prototype.genMethod = function(method) {
   this.extendsType.genMethod(method);
 }
 ParameterType.prototype.isSubtypeOf = function(child) {
   return true;
 }
 ParameterType.prototype.resolveMember = function(memberName) {
   return this.extendsType.resolveMember(memberName);
 }
 ParameterType.prototype.getConstructor = function(constructorName) {
   world.internalError('no constructors on type parameters yet');
 }
+ParameterType.prototype.getOrMakeConcreteType = function(typeArgs) {
+  world.internalError('no concrete types of type parameters yet', this.get$span());
+}
 ParameterType.prototype.resolveTypeParams = function(inType) {
   return inType.typeArguments.$index(this.name);
 }
+ParameterType.prototype.addDirectSubtype = function(type) {
+  world.internalError('no subtypes of type parameters yet', this.get$span());
+}
 ParameterType.prototype.resolve = function(inType) {
   if ($notnull_bool(this.typeParameter.extendsType != null)) {
     this.extendsType = inType.resolveType(this.typeParameter.extendsType, true);
   }
   else {
     this.extendsType = world.objectType;
   }
 }
 // ********** Code for ConcreteType **************
 function ConcreteType(name, genericType, typeArguments, typeArgsInOrder) {
   this.genericType = genericType;
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
   lang_Type.call(this, name);
   // Initializers done
 }
 $inherits(ConcreteType, lang_Type);
 ConcreteType.prototype.get$genericType = function() { return this.genericType; };
 ConcreteType.prototype.get$typeArgsInOrder = function() { return this.typeArgsInOrder; };
 ConcreteType.prototype.set$typeArgsInOrder = function(value) { return this.typeArgsInOrder = value; };
 ConcreteType.prototype.get$isList = function() {
   return this.genericType.get$isList();
 }
 ConcreteType.prototype.get$isClass = function() {
-  return this.genericType.get$isClass();
+  return this.genericType.isClass;
 }
 ConcreteType.prototype.get$library = function() {
-  return this.genericType.get$library();
+  return this.genericType.library;
 }
 ConcreteType.prototype.get$span = function() {
   return this.genericType.get$span();
 }
 ConcreteType.prototype.get$hasTypeParams = function() {
   return this.typeArguments.getValues().some((function (e) {
     return (e instanceof ParameterType);
   })
   );
 }
+ConcreteType.prototype.get$members = function() { return this.members; };
+ConcreteType.prototype.set$members = function(value) { return this.members = value; };
+ConcreteType.prototype.get$constructors = function() { return this.constructors; };
+ConcreteType.prototype.set$constructors = function(value) { return this.constructors = value; };
+ConcreteType.prototype.get$factories = function() { return this.factories; };
+ConcreteType.prototype.set$factories = function(value) { return this.factories = value; };
 ConcreteType.prototype.resolveTypeParams = function(inType) {
   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(inType);
     if ($notnull_bool($ne(newType, t))) needsNewType = true;
     newTypeArgs.add(newType);
   }
   if ($notnull_bool(!$notnull_bool(needsNewType))) return this;
-  return this.genericType.getOrMakeConcreteType(newTypeArgs);
+  return this.genericType.getOrMakeConcreteType((newTypeArgs && newTypeArgs.is$List$Type()));
 }
 ConcreteType.prototype.getOrMakeConcreteType = function(typeArgs) {
   return this.genericType.getOrMakeConcreteType(typeArgs);
 }
 ConcreteType.prototype.get$parent = function() {
-  return this.genericType.get$parent();
+  return this.genericType.parent;
 }
 ConcreteType.prototype.get$interfaces = function() {
-  if ($notnull_bool(this._interfaces == null && this.genericType.get$interfaces() != null)) {
+  if ($notnull_bool(this._interfaces == null && this.genericType.interfaces != null)) {
     this._interfaces = [];
-    var $list = this.genericType.get$interfaces();
+    var $list = this.genericType.interfaces;
     for (var $i = 0;$i < $list.length; $i++) {
       var i = $list.$index($i);
       this._interfaces.add(i.resolveTypeParams(this));
     }
   }
   return this._interfaces;
 }
 ConcreteType.prototype.getCallMethod = function() {
   return this.genericType.getCallMethod();
 }
@@ skipping 52 matching lines @@
 }
 ConcreteType.prototype.resolveMember = function(memberName) {
   var $0;
   var mem = this.getMember(memberName);
   if ($notnull_bool(mem == null)) return null;
   var ret = new MemberSet((mem && mem.is$Member()));
   if ($notnull_bool(mem.get$isStatic())) return ret;
   var $list = this.genericType.get$subtypes();
   for (var $i = this.genericType.get$subtypes().iterator(); $i.hasNext(); ) {
     var t = $i.next();
-    var m = t.members.$index(memberName);
+    var m = t.get$members().$index(memberName);
     if ($notnull_bool($ne(m, null))) ret.add(m);
   }
   return ret;
 }
 ConcreteType.prototype.resolveType = function(node, isRequired) {
   var ret = this.genericType.resolveType(node, isRequired);
   return ret;
 }
 ConcreteType.prototype.addDirectSubtype = function(type) {
   this.genericType.addDirectSubtype(type);
@@ skipping 18 matching lines @@
 DefinedType.prototype.get$definition = function() { return this.definition; };
 DefinedType.prototype.set$definition = function(value) { return this.definition = value; };
 DefinedType.prototype.get$library = function() { return this.library; };
 DefinedType.prototype.get$isClass = function() { return this.isClass; };
 DefinedType.prototype.get$parent = function() { return this.parent; };
 DefinedType.prototype.set$parent = function(value) { return this.parent = value; };
 DefinedType.prototype.get$interfaces = function() { return this.interfaces; };
 DefinedType.prototype.set$interfaces = function(value) { return this.interfaces = value; };
 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.setDefinition = function(def) {
-  $assert(this.definition == null, "definition == null", "type.dart", 541, 12);
+  $assert(this.definition == null, "definition == null", "type.dart", 558, 12);
   this.definition = def;
-  if ($notnull_bool((this.definition instanceof TypeDefinition) && this.definition.nativeType != null)) {
+  if ($notnull_bool((this.definition instanceof TypeDefinition) && this.definition.get$nativeType() != null)) {
     this.isNativeType = true;
   }
   if ($notnull_bool(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);
       var paramName = tp.get$name().get$name();
       this.typeParameters.add(new ParameterType($assert_String(paramName), tp));
@@ skipping 84 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(this);
     interfaces.add(resolvedInterface);
   }
   return interfaces;
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
-  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 657, 12);
+  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 674, 12);
   this.directSubtypes.add(type);
 }
 DefinedType.prototype.get$subtypes = function() {
   var $0;
   if ($notnull_bool(this._subtypes == null)) {
     this._subtypes = new HashSetImplementation$Type();
     var $list = this.directSubtypes;
     for (var $i = this.directSubtypes.iterator(); $i.hasNext(); ) {
       var st = $i.next();
       this._subtypes.add(st);
@@ skipping 41 matching lines @@
   for (var i = 0;
    $notnull_bool(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 ($notnull_bool((this.definition instanceof TypeDefinition))) {
+    var typeDef = (($0 = this.definition) && $0.is$TypeDefinition());
     if ($notnull_bool(this.isClass)) {
-      if ($notnull_bool(this.definition.extendsTypes != null && this.definition.extendsTypes.length > 0)) {
-        if ($notnull_bool(this.definition.extendsTypes.length > 1)) {
-          world.error('more than one base class', this.definition.extendsTypes.$index(1).get$span());
+      if ($notnull_bool(typeDef.extendsTypes != null && typeDef.extendsTypes.length > 0)) {
+        if ($notnull_bool(typeDef.extendsTypes.length > 1)) {
+          world.error('more than one base class', typeDef.extendsTypes.$index(1).get$span());
         }
-        var extendsTypeRef = this.definition.extendsTypes.$index(0);
+        var extendsTypeRef = typeDef.extendsTypes.$index(0);
         if ($notnull_bool((extendsTypeRef instanceof GenericTypeReference))) {
           var g = (extendsTypeRef && extendsTypeRef.is$GenericTypeReference());
           this.parent = this.resolveType(g.baseType, true);
         }
         this.parent = this.resolveType((extendsTypeRef && extendsTypeRef.is$TypeReference()), true);
         if ($notnull_bool(!$notnull_bool(this.parent.get$isClass()))) {
-          world.error('class may not extend an interface - use implements', this.definition.extendsTypes.$index(0).get$span());
+          world.error('class may not extend an interface - use implements', typeDef.extendsTypes.$index(0).get$span());
         }
         this.parent.addDirectSubtype(this);
         if ($notnull_bool(this._cycleInClassExtends())) {
           world.error(('class "' + this.name + '" has a cycle in its inheritance chain'), extendsTypeRef.get$span());
         }
       }
       else {
         if ($notnull_bool(!$notnull_bool(this.get$isObject()))) {
           this.parent = world.objectType;
         }
       }
-      this.interfaces = this._resolveInterfaces(this.definition.implementsTypes);
-      if ($notnull_bool(this.definition.factoryType != null)) {
-        world.error('factory not allowed on classes', this.definition.factoryType.span);
+      this.interfaces = this._resolveInterfaces(typeDef.implementsTypes);
+      if ($notnull_bool(typeDef.factoryType != null)) {
+        world.error('factory not allowed on classes', typeDef.factoryType.span);
       }
     }
     else {
-      if ($notnull_bool(this.definition.implementsTypes != null && this.definition.implementsTypes.length > 0)) {
-        world.error('implements not allowed on interfaces (use extends)', this.definition.implementsTypes.$index(0).get$span());
+      if ($notnull_bool(typeDef.implementsTypes != null && typeDef.implementsTypes.length > 0)) {
+        world.error('implements not allowed on interfaces (use extends)', typeDef.implementsTypes.$index(0).get$span());
       }
-      this.interfaces = this._resolveInterfaces(this.definition.extendsTypes);
+      this.interfaces = this._resolveInterfaces(typeDef.extendsTypes);
       var res = this._cycleInInterfaceExtends();
       if ($notnull_bool(res >= 0)) {
-        world.error(('interface "' + this.name + '" has a cycle in its inheritance chain'), this.definition.extendsTypes.$index(res).get$span());
+        world.error(('interface "' + this.name + '" has a cycle in its inheritance chain'), typeDef.extendsTypes.$index(res).get$span());
       }
-      if ($notnull_bool(this.definition.factoryType != null)) {
-        this.factory_ = this.resolveType(this.definition.factoryType, true);
+      if ($notnull_bool(typeDef.factoryType != null)) {
+        this.factory_ = this.resolveType(typeDef.factoryType, true);
         if ($notnull_bool(this.factory_ == null)) {
-          world.info(('unresolved factory: ' + this.definition.factoryType.get$name().get$name() + ''), this.definition.factoryType.get$name().get$span());
+          world.warning('unresolved factory', typeDef.factoryType.span);
         }
       }
     }
   }
   else if ($notnull_bool((this.definition instanceof FunctionTypeDefinition))) {
     this.interfaces = [world.functionType];
   }
   if ($notnull_bool(this.typeParameters != null)) {
     var $list = this.typeParameters;
     for (var $i = 0;$i < $list.length; $i++) {
@@ skipping 101 matching lines @@
     if ($notnull_bool(this.factory_ != null)) {
       return this.factory_.getFactory(this, constructorName);
     }
     return ret;
   }
   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 ($notnull_bool(name == '' && this.definition != null && this.isClass && this.constructors.get$length() == 0)) {
     var span = this.definition.span;
     var inits = null, body = null;
     if ($notnull_bool(this.isNativeType)) {
       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 c = new FunctionDefinition(null, null, this.definition.get$name(), [], inits, body, (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()));
     this.addMethod(null, (c && c.is$FunctionDefinition()));
     this.constructors.$index('').resolve(this);
     return this.constructors.$index('');
   }
   return null;
 }
 DefinedType.prototype.getMember = function(memberName) {
   var $0;
   var member = (($0 = this.members.$index(memberName)) && $0.is$Member());
   if ($notnull_bool(member != null)) {
@@ skipping 59 matching lines @@
   }
   else {
     var $list = this.get$subtypes();
     for (var $i = this.get$subtypes().iterator(); $i.hasNext(); ) {
       var t = $i.next();
       var m;
       if ($notnull_bool(!$notnull_bool(this.isClass) && t.get$isClass())) {
         m = t.getMember(memberName);
       }
       else {
-        m = t.members.$index(memberName);
+        m = t.get$members().$index(memberName);
       }
       if ($notnull_bool($ne(m, null))) ret.add((m && m.is$Member()));
     }
     return ret;
   }
 }
 DefinedType.prototype._createNotEqualMember = function() {
   var $0;
   var eq = (($0 = this.members.$index('\$eq')) && $0.is$MethodMember());
   if ($notnull_bool(eq == null)) {
@@ skipping 17 matching lines @@
   }
   else {
     return type.name.name;
   }
 }
 DefinedType.prototype.resolveType = function(node, typeErrors) {
   var $0;
   if ($notnull_bool(node == null)) return world.varType;
   if ($notnull_bool(node.type != null)) return node.type;
   if ($notnull_bool((node instanceof NameTypeReference))) {
+    var typeRef = (node && node.is$NameTypeReference());
     var name;
-    if ($notnull_bool(node.names != null)) {
-      name = $assert_String(node.names.last().get$name());
+    if ($notnull_bool(typeRef.names != null)) {
+      name = $assert_String(typeRef.names.last().get$name());
     }
     else {
-      name = $assert_String(node.get$name().get$name());
+      name = typeRef.name.name;
     }
     if ($notnull_bool(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))) {
-          node.type = (tp && tp.is$lang_Type());
+          typeRef.type = (tp && tp.is$lang_Type());
         }
       }
     }
-    if ($notnull_bool(node.type == null)) {
-      node.type = this.library.findType((node && node.is$NameTypeReference()));
+    if ($notnull_bool(typeRef.type == null)) {
+      typeRef.type = this.library.findType(typeRef);
     }
-    if ($notnull_bool(node.type == null)) {
-      var message = ('can not find type ' + DefinedType._getDottedName((node && node.is$NameTypeReference())) + '');
+    if ($notnull_bool(typeRef.type == null)) {
+      var message = ('can not find type ' + DefinedType._getDottedName(typeRef) + '');
       if ($notnull_bool(typeErrors)) {
-        world.error($assert_String(message), node.span);
-        node.type = world.objectType;
+        world.error($assert_String(message), typeRef.span);
+        typeRef.type = world.objectType;
       }
       else {
-        world.warning($assert_String(message), node.span);
-        node.type = world.varType;
+        world.warning($assert_String(message), typeRef.span);
+        typeRef.type = world.varType;
       }
     }
   }
   else if ($notnull_bool((node instanceof GenericTypeReference))) {
-    var baseType = this.resolveType(node.baseType, typeErrors);
+    var typeRef = (node && node.is$GenericTypeReference());
+    var baseType = this.resolveType(typeRef.baseType, typeErrors);
     if ($notnull_bool(!$notnull_bool(baseType.get$isGeneric()))) {
-      world.error(('' + baseType.get$name() + ' is not generic'), node.span);
+      world.error(('' + baseType.get$name() + ' is not generic'), typeRef.span);
       return null;
     }
-    if ($notnull_bool(node.typeArguments.length != baseType.get$typeParameters().length)) {
-      world.error('wrong number of type arguments', node.span);
+    if ($notnull_bool(typeRef.typeArguments.length != baseType.get$typeParameters().length)) {
+      world.error('wrong number of type arguments', typeRef.span);
       return null;
     }
     var typeArgs = [];
     for (var i = 0;
-     $notnull_bool(i < node.typeArguments.length); i++) {
+     $notnull_bool(i < typeRef.typeArguments.length); i++) {
       var extendsType = baseType.get$typeParameters().$index(i).extendsType;
-      var typeArg = this.resolveType((($0 = node.typeArguments.$index(i)) && $0.is$TypeReference()), typeErrors);
+      var typeArg = this.resolveType((($0 = typeRef.typeArguments.$index(i)) && $0.is$TypeReference()), typeErrors);
       typeArgs.add(typeArg);
       if ($notnull_bool($ne(extendsType, null) && !(typeArg instanceof ParameterType))) {
-        typeArg.ensureSubtypeOf((extendsType && extendsType.is$lang_Type()), node.typeArguments.$index(i).get$span(), typeErrors);
+        typeArg.ensureSubtypeOf((extendsType && extendsType.is$lang_Type()), typeRef.typeArguments.$index(i).get$span(), typeErrors);
       }
     }
-    node.type = baseType.getOrMakeConcreteType(typeArgs);
+    typeRef.type = baseType.getOrMakeConcreteType(typeArgs);
   }
   else if ($notnull_bool((node instanceof FunctionTypeReference))) {
+    var typeRef = (node && node.is$FunctionTypeReference());
     var name = '';
-    if ($notnull_bool(node.func.name != null)) name = node.func.name.name;
-    node.type = this.library.getOrAddFunctionType($assert_String(name), node.func, this);
+    if ($notnull_bool(typeRef.func.name != null)) name = typeRef.func.name.name;
+    typeRef.type = this.library.getOrAddFunctionType($assert_String(name), typeRef.func, this);
   }
   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", 1135, 12);
+  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1156, 12);
   var names = [this.name];
   var typeMap = $map([]);
   for (var i = 0;
    $notnull_bool(i < typeArgs.length); i++) {
     var paramName = this.typeParameters.$index(i).get$name();
     typeMap.$setindex(paramName, typeArgs.$index(i));
     names.add(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;
 }
 DefinedType.prototype.getCallStub = function(args) {
-  $assert(this.get$isFunction(), "isFunction", "type.dart", 1155, 12);
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1176, 12);
   var name = _getCallStubName('call', args);
   if ($notnull_bool(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;
 }
 // ********** Code for FixedCollection **************
@@ skipping 12 matching lines @@
 }
 FixedCollection.prototype.filter = function(f) {
   return Collections.filter(this, new ListFactory$E(), f);
 }
 FixedCollection.prototype.some = function(f) {
   return Collections.some(this, f);
 }
 FixedCollection.prototype.isEmpty = function() {
   return this.length == 0;
 }
-FixedCollection.prototype.forEach$1 = FixedCollection.prototype.forEach;
 // ********** Code for FixedCollection$Type **************
 function FixedCollection$Type(value, length) {
   this.value = value;
   this.length = length;
   // Initializers done
 }
 $inherits(FixedCollection$Type, FixedCollection);
 FixedCollection$Type.prototype.is$Iterable = function(){return this;};
 // ********** Code for FixedIterator **************
 function FixedIterator(value, length) {
@@ skipping 26 matching lines @@
   this.needsTemp = needsTemp;
   this.isType = isType;
   // Initializers done
   if ($notnull_bool(this.type == null)) this.type = world.varType;
 }
 Value.prototype.is$Value = function(){return this;};
 Value.prototype.get$isConst = function() {
   return false;
 }
 Value.prototype.get_ = function(context, name, node) {
-  var member = this._resolveMember(context, name, node);
+  var member = this._resolveMember(context, name, node, false);
   if ($notnull_bool($ne(member, null))) {
     member = member.get_$3(context, node, this);
   }
   if ($notnull_bool($ne(member, null))) {
     return member;
   }
   else {
     return this.invokeNoSuchMethod(context, ('get:' + name + ''), node);
   }
 }
 Value.prototype.set_ = function(context, name, node, value, isDynamic) {
-  var member = this._resolveMember(context, name, node);
+  var member = this._resolveMember(context, name, node, isDynamic);
   if ($notnull_bool($ne(member, null))) {
     member = member.set_(context, node, this, value, isDynamic);
   }
   if ($notnull_bool($ne(member, null))) {
     return member;
   }
   else {
     return this.invokeNoSuchMethod(context, ('set:' + name + ''), node, new Arguments(null, [value]));
   }
 }
 Value.prototype.invoke = function(context, name, node, args, isDynamic) {
   if ($notnull_bool(this.type.get$isVar() && name == '\$ne')) {
     if ($notnull_bool(args.values.length != 1)) {
       world.warning('wrong number of arguments for !=', node.span);
     }
     world.gen.corejs.useOperator('\$ne');
     return new Value(null, ('\$ne(' + this.code + ', ' + args.values.$index(0).code + ')'), false, true, false);
   }
   if ($notnull_bool(name == '\$call')) {
     if ($notnull_bool(this.isType)) {
       world.error('must use "new" or "const" to construct a new instance', node.span);
     }
     if ($notnull_bool(this.type.needsVarCall(args))) {
       return this._varCall(context, args);
     }
   }
-  var member = this._resolveMember(context, name, node);
+  var member = this._resolveMember(context, name, node, isDynamic);
   if ($notnull_bool(member == null)) {
     return this.invokeNoSuchMethod(context, name, node, args);
   }
   else {
     return member.invoke(context, node, this, args, isDynamic);
   }
 }
 Value.prototype.canInvoke = function(context, name, args) {
   if ($notnull_bool(this.type.get$isVar() && name == '\$ne')) {
     return true;
   }
   if ($notnull_bool(this.type.get$isVarOrFunction() && name == '\$call')) {
     return true;
   }
-  var member = this._tryResolveMember(context, name);
+  var member = this._resolveMember(context, name, null, true);
   return $ne(member, null) && member.canInvoke(context, args);
 }
-Value.prototype._tryResolveMember = function(context, name) {
-  var member = null;
-  if ($notnull_bool(!$notnull_bool(this.type.get$isVar()))) {
+Value.prototype._hasOverriddenNoSuchMethod = function() {
+  if ($notnull_bool(this.isSuper)) {
+    var m = this.type.getMember('noSuchMethod');
+    return $ne(m, null) && !$notnull_bool(m.declaringType.get$isObject());
+  }
+  else {
+    return this.type.resolveMember('noSuchMethod').members.length > 1;
+  }
+}
+Value.prototype._resolveMember = function(context, name, node, isDynamic) {
+  var member;
+  if ($notnull_bool(!$notnull_bool(this.type.get$isVar()) && !(this.type instanceof ParameterType))) {
     if ($notnull_bool(this.isSuper)) {
-      return this.type.getMember(name);
+      member = this.type.getMember(name);
     }
     else {
       member = this.type.resolveMember(name);
     }
+    if ($notnull_bool($ne(member, null) && this.isType && !$notnull_bool(member.get$isStatic()))) {
+      if ($notnull_bool(!$notnull_bool(isDynamic))) {
+        world.error('can not refer to instance member as static', node.span);
+      }
+      return null;
+    }
+    if ($notnull_bool(member == null && !$notnull_bool(isDynamic) && !$notnull_bool(this._hasOverriddenNoSuchMethod()))) {
+      var typeName = $notnull_bool(this.type.name == null) ? this.type.get$library().name : this.type.name;
+      var message = ('can not resolve "' + name + '" on "' + typeName + '"');
+      if ($notnull_bool(this.isType)) {
+        world.error($assert_String(message), node.span);
+      }
+      else {
+        world.warning($assert_String(message), node.span);
+      }
+    }
   }
-  if ($notnull_bool(member == null)) {
+  if ($notnull_bool(member == null && !$notnull_bool(this.isSuper) && !$notnull_bool(this.isType))) {
     member = context.findMembers(name);
+    if ($notnull_bool(member == null && !$notnull_bool(isDynamic))) {
+      world.warning(('' + name + ' is not defined anywhere in the world.'), node.span);
+    }
   }
   return member;
 }
-Value.prototype._resolveMember = function(context, name, node) {
-  var member = this._tryResolveMember(context, name);
-  if ($notnull_bool($ne(member, null))) {
-    if ($notnull_bool(this.isType && !$notnull_bool(member.get$isStatic()))) {
-      world.error('can not refer to instance member as static', node.span);
-    }
-    return member;
-  }
-  else {
-    if ($notnull_bool(this._tryResolveMember(context, 'noSuchMethod').members.length > 1)) {
-      return null;
-    }
-    var typeName = $notnull_bool(this.type.name == null) ? this.type.get$library().name : this.type.name;
-    var message = ('can not resolve "' + name + '" on "' + typeName + '"');
-    if ($notnull_bool(this.isType)) {
-      world.error($assert_String(message), node.span);
-    }
-    else {
-      world.warning($assert_String(message), node.span);
-    }
-    if ($notnull_bool(context.findMembers(name) == null)) {
-      world.warning(('' + name + ' is not defined anywhere in the world.'), node.span);
-    }
-    return null;
-  }
-}
 Value.prototype.checkFirstClass = function(span) {
   if ($notnull_bool(this.isType)) {
     world.error('Types are not first class', span);
   }
 }
 Value.prototype._varCall = function(context, args) {
   var stub = world.functionType.getCallStub(args);
   return new Value(null, ('' + this.code + '.' + stub.get$name() + '(' + args.getCode() + ')'), false, true, false);
 }
 Value.prototype.needsConversion = function(toType) {
@@ skipping 143 matching lines @@
   var pos = '';
   if ($notnull_bool(args != null)) {
     var argsCode = [];
     for (var i = 0;
      $notnull_bool(i < args.get$length()); i++) {
       argsCode.add(args.values.$index(i).code);
     }
     pos = Strings.join((argsCode && argsCode.is$List$String()), ", ");
   }
   var noSuchArgs = [new Value(world.stringType, ('"' + name + '"'), false, true, false), new Value(world.listType, ('[' + pos + ']'), false, true, false)];
-  return this._tryResolveMember(context, 'noSuchMethod').invoke$4(context, node, this, new Arguments(null, noSuchArgs));
+  return this._resolveMember(context, 'noSuchMethod', node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs));
 }
 Value.prototype.invokeSpecial = function(name, args, returnType) {
-  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 432, 12);
-  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 433, 12);
+  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 443, 12);
+  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 444, 12);
   var argsString = args.getCode();
   if ($notnull_bool(name == '\$index' || name == '\$setindex')) {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), false, true, false);
   }
   else {
     if ($notnull_bool(argsString.length > 0)) argsString = (', ' + argsString + '');
     world.gen.corejs.useOperator(name);
     return new Value(returnType, ('' + name + '(' + this.code + '' + argsString + ')'), false, true, false);
   }
 }
@@ skipping 184 matching lines @@
 World.prototype.get$dom = function() {
   return this.libraries.$index('dart:dom');
 }
 World.prototype.get$functionType = function() { return this.functionType; };
 World.prototype.set$functionType = function(value) { return this.functionType = value; };
 World.prototype.init = function() {
   var $0;
   this.corelib = new Library(this.readFile('dart:core'));
   this.libraries.$setindex('dart:core', this.corelib);
   this._todo.add(this.corelib);
-  this.voidType = (($0 = this._addToCoreLib('void', false)) && $0.is$lang_Type());
-  this.dynamicType = (($0 = this._addToCoreLib('Dynamic', false)) && $0.is$lang_Type());
+  this.voidType = (($0 = this._addToCoreLib('void', false)) && $0.is$DefinedType());
+  this.dynamicType = (($0 = this._addToCoreLib('Dynamic', false)) && $0.is$DefinedType());
   this.varType = this.dynamicType;
-  this.objectType = (($0 = this._addToCoreLib('Object', true)) && $0.is$lang_Type());
-  this.numType = (($0 = this._addToCoreLib('num', false)) && $0.is$lang_Type());
-  this.intType = (($0 = this._addToCoreLib('int', false)) && $0.is$lang_Type());
-  this.doubleType = (($0 = this._addToCoreLib('double', false)) && $0.is$lang_Type());
-  this.boolType = (($0 = this._addToCoreLib('bool', false)) && $0.is$lang_Type());
-  this.stringType = (($0 = this._addToCoreLib('String', false)) && $0.is$lang_Type());
-  this.listType = (($0 = this._addToCoreLib('List', false)) && $0.is$lang_Type());
-  this.mapType = (($0 = this._addToCoreLib('Map', false)) && $0.is$lang_Type());
-  this.functionType = (($0 = this._addToCoreLib('Function', false)) && $0.is$lang_Type());
+  this.objectType = (($0 = this._addToCoreLib('Object', true)) && $0.is$DefinedType());
+  this.numType = (($0 = this._addToCoreLib('num', false)) && $0.is$DefinedType());
+  this.intType = (($0 = this._addToCoreLib('int', false)) && $0.is$DefinedType());
+  this.doubleType = (($0 = this._addToCoreLib('double', false)) && $0.is$DefinedType());
+  this.boolType = (($0 = this._addToCoreLib('bool', false)) && $0.is$DefinedType());
+  this.stringType = (($0 = this._addToCoreLib('String', false)) && $0.is$DefinedType());
+  this.listType = (($0 = this._addToCoreLib('List', false)) && $0.is$DefinedType());
+  this.mapType = (($0 = this._addToCoreLib('Map', false)) && $0.is$DefinedType());
+  this.functionType = (($0 = this._addToCoreLib('Function', false)) && $0.is$DefinedType());
 }
 World.prototype._addMember = function(member) {
   $assert(!$notnull_bool(member.get$isPrivate()), "!member.isPrivate", "world.dart", 141, 12);
   if ($notnull_bool(member.get$isStatic())) {
     if ($notnull_bool(member.declaringType.get$isTop())) {
       this._addTopName(member);
     }
     return;
   }
   var mset = this._members.$index(member.name);
   if ($notnull_bool(mset == null)) {
     mset = new MemberSet(member);
     this._members.$setindex(mset.get$name(), mset);
   }
   else {
-    mset.members.add(member);
+    mset.get$members().add(member);
   }
 }
 World.prototype._addTopName = function(named) {
   var existing = this._topNames.$index(named.get$name());
   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().name + '"'));
     if ($notnull_bool(named.get$isNative())) {
       if ($notnull_bool(existing.get$isNative())) {
         world.internalError(('conflicting native names "' + named.get$name() + '" ') + ('(already defined in ' + existing.get$span().get$locationText() + ')'), named.get$span());
       }
@@ skipping 84 matching lines @@
   })
   );
   this.withTiming('resolve top level', (function () {
     $this.resolveAll();
   })
   );
   this.withTiming('generate code', (function () {
     var $0;
     var mainMembers = lib.topType.resolveMember('main');
     var main = null;
-    if ($notnull_bool(mainMembers == null || mainMembers.members.length == 0)) {
+    if ($notnull_bool(mainMembers == null || mainMembers.get$members().length == 0)) {
       $this.fatal('no main method specified');
     }
-    else if ($notnull_bool(mainMembers.members.length > 1)) {
-      var $list = mainMembers.members;
-      for (var $i = mainMembers.members.iterator(); $i.hasNext(); ) {
+    else if ($notnull_bool(mainMembers.get$members().length > 1)) {
+      var $list = mainMembers.get$members();
+      for (var $i = mainMembers.get$members().iterator(); $i.hasNext(); ) {
         var m = $i.next();
         main = m;
         $this.error('more than one main member (using last?)', main.get$span());
       }
     }
     else {
-      main = mainMembers.members.$index(0);
+      main = mainMembers.get$members().$index(0);
     }
     var codeWriter = new CodeWriter();
     $this.gen = new WorldGenerator(main, codeWriter);
     $this.gen.run();
     $this.jsBytesWritten = codeWriter.get$text().length;
   })
   );
 }
 World.prototype.getGeneratedCode = function() {
   if ($notnull_bool(this.legCode != null)) {
@@ skipping 361 matching lines @@
 }
 // ********** Code for VarMethodSet **************
 function VarMethodSet(name, members, callArgs, returnType) {
   this.members = members;
   this.returnType = returnType;
   this.args = callArgs.toCallStubArgs();
   VarMember.call(this, name);
   // Initializers done
 }
 $inherits(VarMethodSet, VarMember);
+VarMethodSet.prototype.get$members = function() { return this.members; };
 VarMethodSet.prototype.get$returnType = function() { return this.returnType; };
 VarMethodSet.prototype.get$baseName = function() {
   return this.members.$index(0).get$name();
 }
 VarMethodSet.prototype.invoke = function(context, node, target, args) {
   this._invokeMembers(context, node);
   return VarMember.prototype.invoke.call(this, context, node, target, args);
 }
 VarMethodSet.prototype._invokeMembers = function(context, node) {
   if ($notnull_bool(this._fallbackStubs != null)) return;
@@ skipping 69 matching lines @@
   if ($notnull_bool(current == null && i.hasNext())) {
     current = i.next();
   }
   while ($notnull_bool(i.hasNext())) {
     current = callback.call$2(current, i.next());
   }
   return current;
 }
 function orderValuesByKeys(map) {
   var $0;
-  var keys = map.getKeys();
+  var keys = (($0 = map.getKeys()) && $0.is$List());
   keys.sort((function (x, y) {
     return x.compareTo(y);
   })
   );
   var values = [];
-  for (var $i = keys.iterator(); $i.hasNext(); ) {
-    var k = $i.next();
+  for (var $i = 0;$i < keys.length; $i++) {
+    var k = keys.$index($i);
     values.add(map.$index(k));
   }
   return values;
 }
 function isMultilineString(text) {
   return text.startsWith('"""') || text.startsWith("'''");
 }
 function isRawMultilineString(text) {
   return text.startsWith('@"""') || text.startsWith("@'''");
 }
@@ skipping 209 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 RunEntry(function () {main();}, []);