Simple fix to get noSuchMethod working on private members

frog/minfrog

 #!/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) { return 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 121 matching lines @@
 Clock.frequency = function() {
   return 1000;
 }
 // ********** Code for Object **************
 Object.prototype.get$dynamic = function() {
   return this;
 }
 Object.prototype.noSuchMethod = function(name, args) {
   $throw(new NoSuchMethodException(this, name, args));
 }
+Object.prototype._checkExtends$0 = function() {
+  return this.noSuchMethod("_checkExtends", []);
+};
+Object.prototype._checkNonStatic$1 = function($0) {
+  return this.noSuchMethod("_checkNonStatic", [$0]);
+};
 Object.prototype._get$3 = function($0, $1, $2) {
   return this.noSuchMethod("_get", [$0, $1, $2]);
 };
+Object.prototype._get$3$isDynamic = function($0, $1, $2, isDynamic) {
+  return this.noSuchMethod("_get", [$0, $1, $2, isDynamic]);
+};
+Object.prototype._get$4 = function($0, $1, $2, $3) {
+  return this.noSuchMethod("_get", [$0, $1, $2, $3]);
+};
 Object.prototype._set$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("_set", [$0, $1, $2, $3]);
 };
+Object.prototype._set$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
+  return this.noSuchMethod("_set", [$0, $1, $2, $3, isDynamic]);
+};
+Object.prototype._set$5 = function($0, $1, $2, $3, $4) {
+  return this.noSuchMethod("_set", [$0, $1, $2, $3, $4]);
+};
+Object.prototype._wrapDomCallback$2 = function($0, $1) {
+  return this.noSuchMethod("_wrapDomCallback", [$0, $1]);
+};
 Object.prototype.add$1 = function($0) {
   return this.noSuchMethod("add", [$0]);
 };
 Object.prototype.addAll$1 = function($0) {
   return this.noSuchMethod("addAll", [$0]);
 };
 Object.prototype.addDirectSubtype$1 = function($0) {
   return this.noSuchMethod("addDirectSubtype", [$0]);
 };
 Object.prototype.addMethod$2 = function($0, $1) {
@@ skipping 13 matching lines @@
 };
 Object.prototype.compareTo$1 = function($0) {
   return this.noSuchMethod("compareTo", [$0]);
 };
 Object.prototype.computeValue$0 = function() {
   return this.noSuchMethod("computeValue", []);
 };
 Object.prototype.contains$1 = function($0) {
   return this.noSuchMethod("contains", [$0]);
 };
+Object.prototype.containsKey$1 = function($0) {
+  return this.noSuchMethod("containsKey", [$0]);
+};
 Object.prototype.convertTo$3 = function($0, $1, $2) {
   return this.noSuchMethod("convertTo", [$0, $1, $2]);
 };
 Object.prototype.convertTo$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("convertTo", [$0, $1, $2, $3]);
 };
 Object.prototype.copyWithNewType$2 = function($0, $1) {
   return this.noSuchMethod("copyWithNewType", [$0, $1]);
 };
 Object.prototype.end$0 = function() {
@@ skipping 649 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.containsKey$1 = HashMapImplementation.prototype.containsKey;
 HashMapImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 HashMapImplementation.prototype.getKeys$0 = HashMapImplementation.prototype.getKeys;
 HashMapImplementation.prototype.getValues$0 = HashMapImplementation.prototype.getValues;
 HashMapImplementation.prototype.isEmpty$0 = HashMapImplementation.prototype.isEmpty;
 // ********** Code for HashMapImplementation_E$E **************
 function HashMapImplementation_E$E() {
   // Initializers done
   this._numberOfEntries = 0;
@@ skipping 352 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.containsKey$1 = LinkedHashMapImplementation.prototype.containsKey;
 LinkedHashMapImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 LinkedHashMapImplementation.prototype.getKeys$0 = LinkedHashMapImplementation.prototype.getKeys;
 LinkedHashMapImplementation.prototype.getValues$0 = LinkedHashMapImplementation.prototype.getValues;
 LinkedHashMapImplementation.prototype.isEmpty$0 = LinkedHashMapImplementation.prototype.isEmpty;
 // ********** Code for DoubleLinkedQueueEntry **************
 function DoubleLinkedQueueEntry(e) {
   // Initializers done
   this._element = e;
@@ skipping 706 matching lines @@
 CoreJs.prototype.generate$1 = CoreJs.prototype.generate;
 // ********** Code for Element **************
 function Element(name, _enclosingElement) {
   this.name = name;
   this._enclosingElement = _enclosingElement;
   // Initializers done
   this._jsname = $globals.world.toJsIdentifier(this.name);
 }
 Element.prototype.get$name = function() { return this.name; };
 Element.prototype.set$name = function(value) { return this.name = value; };
+Element.prototype.get$_jsname = function() { return this._jsname; };
+Element.prototype.set$_jsname = function(value) { return this._jsname = value; };
 Element.prototype.get$library = function() {
   return null;
 }
 Element.prototype.get$span = function() {
   return null;
 }
 Element.prototype.get$isNative = function() {
   return false;
 }
 Element.prototype.hashCode = function() {
@@ skipping 181 matching lines @@
     this.writer.comment(('//  ********** Natives ' + filename + ' **************'));
     this.writer.writeln(file.get$text());
   }
   lib.topType.markUsed();
   var $$list = this._orderValues(lib.types);
   for (var $$i = 0;$$i < $$list.length; $$i++) {
     var type = $$list.$index($$i);
     if ((type.get$isUsed() || type.get$isHiddenNativeType()) && type.get$isClass()) {
       this.writeType(type);
       if (type.get$isGeneric()) {
-        var $list0 = this._orderValues(type._concreteTypes);
+        var $list0 = this._orderValues(type.get$_concreteTypes());
         for (var $i0 = 0;$i0 < $list0.length; $i0++) {
           var ct = $list0.$index($i0);
           this.writeType(ct);
         }
       }
     }
     else if (type.get$isFunction() && type.get$varStubs().length > 0) {
       this.writer.comment(('// ********** Code for ' + type.get$jsname() + ' **************'));
       this._writeDynamicStubs(type);
     }
@@ skipping 76 matching lines @@
         c.get$generator().writeDefinition$2(this.writer);
       }
     }
   }
   if (!type.get$isTop()) {
     if ((type instanceof ConcreteType)) {
       var c = type;
       this.corejs.ensureInheritsHelper();
       this.writer.writeln(('\$inherits(' + c.get$jsname() + ', ' + c.genericType.get$jsname() + ');'));
       for (var p = c._parent;
-       (p instanceof ConcreteType); p = p._parent) {
+       (p instanceof ConcreteType); p = p.get$_parent()) {
         this._ensureInheritMembersHelper();
         this._mixins.writeln(('\$inheritsMembers(' + c.get$jsname() + ', ' + p.get$jsname() + ');'));
       }
     }
     else if (!type.get$isNative()) {
       if (type.get$parent() != null && !type.get$parent().get$isObject()) {
         this.corejs.ensureInheritsHelper();
         this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$parent().get$jsname() + ');'));
       }
     }
   }
   if (!(type instanceof ConcreteType)) {
     this._maybeIsTest(type, type);
   }
   if (type.get$genericType()._concreteTypes != null) {
     var $$list = this._orderValues(type.get$genericType()._concreteTypes);
     for (var $$i = 0;$$i < $$list.length; $$i++) {
       var ct = $$list.$index($$i);
       this._maybeIsTest(type, ct);
     }
   }
   if (type.get$interfaces() != null) {
     var seen = new HashSetImplementation();
     var worklist = [];
     worklist.addAll(type.get$interfaces());
     seen.addAll(type.get$interfaces());
     while (!worklist.isEmpty()) {
       var interface_ = worklist.removeLast();
       this._maybeIsTest(type, interface_.get$genericType());
-      if (interface_.get$genericType()._concreteTypes != null) {
-        var $$list = this._orderValues(interface_.get$genericType()._concreteTypes);
+      if ($ne(interface_.get$genericType().get$_concreteTypes(), null)) {
+        var $$list = this._orderValues(interface_.get$genericType().get$_concreteTypes());
         for (var $$i = 0;$$i < $$list.length; $$i++) {
           var ct = $$list.$index($$i);
           this._maybeIsTest(type, ct);
         }
       }
       var $$list = interface_.get$interfaces();
       for (var $$i = interface_.get$interfaces().iterator$0(); $$i.hasNext$0(); ) {
         var other = $$i.next$0();
         if (!seen.contains(other)) {
           worklist.addLast(other);
@@ skipping 139 matching lines @@
     this._closedOver = new HashSetImplementation();
   }
   else {
     this.reentrant = reentrant || this.parent.reentrant;
   }
 }
 BlockScope.prototype.get$enclosingMethod = function() { return this.enclosingMethod; };
 BlockScope.prototype.set$enclosingMethod = function(value) { return this.enclosingMethod = value; };
 BlockScope.prototype.get$parent = function() { return this.parent; };
 BlockScope.prototype.set$parent = function(value) { return this.parent = value; };
+BlockScope.prototype.get$_vars = function() { return this._vars; };
+BlockScope.prototype.set$_vars = function(value) { return this._vars = value; };
+BlockScope.prototype.get$_jsNames = function() { return this._jsNames; };
+BlockScope.prototype.set$_jsNames = function(value) { return this._jsNames = value; };
+BlockScope.prototype.get$_closedOver = function() { return this._closedOver; };
+BlockScope.prototype.set$_closedOver = function(value) { return this._closedOver = value; };
 BlockScope.prototype.get$rethrow = function() { return this.rethrow; };
 BlockScope.prototype.set$rethrow = function(value) { return this.rethrow = value; };
 BlockScope.prototype.get$reentrant = function() { return this.reentrant; };
 BlockScope.prototype.set$reentrant = function(value) { return this.reentrant = value; };
 BlockScope.prototype.get$isMethodScope = function() {
   return this.parent == null || $ne(this.parent.enclosingMethod, this.enclosingMethod);
 }
 BlockScope.prototype.get$methodScope = function() {
   var s = this;
   while (!s.get$isMethodScope()) s = s.get$parent();
   return s;
 }
 BlockScope.prototype.lookup = function(name) {
   var ret = this._vars.$index(name);
   if ($ne(ret, null)) return ret;
   for (var s = this.parent;
    $ne(s, null); s = s.get$parent()) {
-    ret = s._vars.$index(name);
+    ret = s.get$_vars().$index(name);
     if ($ne(ret, null)) {
       if ($ne(s.get$enclosingMethod(), this.enclosingMethod)) {
-        s.get$methodScope()._closedOver.add(ret.get$code());
+        s.get$methodScope().get$_closedOver().add$1(ret.get$code());
         if (this.enclosingMethod.captures != null && s.get$reentrant()) {
           this.enclosingMethod.captures.add(ret.get$code());
         }
       }
       return ret;
     }
   }
 }
 BlockScope.prototype._isDefinedInParent = function(name) {
   if (this.get$isMethodScope() && this._closedOver.contains(name)) return true;
   for (var s = this.parent;
    $ne(s, null); s = s.get$parent()) {
-    if (s._vars.containsKey(name)) return true;
-    if (s._jsNames.contains(name)) return true;
-    if (s.get$isMethodScope() && s._closedOver.contains(name)) return true;
+    if (s.get$_vars().containsKey$1(name)) return true;
+    if (s.get$_jsNames().contains$1(name)) return true;
+    if (s.get$isMethodScope() && s.get$_closedOver().contains$1(name)) return true;
   }
   var type = this.enclosingMethod.method.declaringType;
   if (type.get$library().lookup(name, null) != null) return true;
   return false;
 }
 BlockScope.prototype.create = function(name, type, span, isFinal, isParameter) {
   var jsName = $globals.world.toJsIdentifier(name);
   if (this._vars.containsKey(name)) {
     $globals.world.error(('duplicate name "' + name + '"'), span);
   }
@@ skipping 860 matching lines @@
     this._getOutermostMethod().set$needsThis(true);
     return '\$this';
   }
   else {
     return 'this';
   }
 }
 MethodGenerator.prototype._makeThisValue = function(node) {
   if (this.enclosingMethod != null) {
     var outermostMethod = this._getOutermostMethod();
-    outermostMethod._checkNonStatic(node);
+    outermostMethod._checkNonStatic$1(node);
     outermostMethod.set$needsThis(true);
     return new Value(outermostMethod.method.get$declaringType(), '\$this', node != null ? node.span : null, false);
   }
   else {
     this._checkNonStatic(node);
     return new Value(this.method.declaringType, 'this', node != null ? node.span : null, false);
   }
 }
 MethodGenerator.prototype.visitLambdaExpression = function(node) {
   var name = (node.func.name != null) ? node.func.name.name : '';
@@ skipping 494 matching lines @@
       text = toDoubleQuote(text);
       text = ('"' + text + '"');
     }
     if (text !== node.text) {
       node.value = text;
       node.text = text;
     }
   }
   return EvaluatedValue.EvaluatedValue$factory(type, node.value, node.text, null);
 }
+MethodGenerator.prototype._checkNonStatic$1 = MethodGenerator.prototype._checkNonStatic;
 MethodGenerator.prototype.visitPostfixExpression$1 = function($0) {
   return this.visitPostfixExpression($0, false);
 };
 MethodGenerator.prototype.writeDefinition$2 = MethodGenerator.prototype.writeDefinition;
 // ********** Code for Arguments **************
 function Arguments(nodes, values) {
   this.nodes = nodes;
   this.values = values;
   // Initializers done
 }
@@ skipping 114 matching lines @@
   this.types = _map(['', this.topType]);
   this.imports = [];
   this.natives = [];
   this.sources = [];
   this._privateMembers = new HashMapImplementation();
 }
 $inherits(Library, Element);
 Library.prototype.get$baseSource = function() { return this.baseSource; };
 Library.prototype.get$types = function() { return this.types; };
 Library.prototype.set$types = function(value) { return this.types = value; };
+Library.prototype.get$_privateMembers = function() { return this._privateMembers; };
+Library.prototype.set$_privateMembers = function(value) { return this._privateMembers = value; };
 Library.prototype.get$topType = function() { return this.topType; };
 Library.prototype.set$topType = function(value) { return this.topType = value; };
 Library.prototype.get$enclosingElement = function() {
   return null;
 }
 Library.prototype.get$library = function() {
   return this;
 }
 Library.prototype.get$isNative = function() {
   return this.topType.isNative;
@@ skipping 36 matching lines @@
       if (member.declaringType.get$isTop()) {
         $globals.world._addTopName(member);
       }
       return;
     }
     var mset = this._privateMembers.$index(member.name);
     if (mset == null) {
       var $$list = $globals.world.libraries.getValues();
       for (var $$i = $globals.world.libraries.getValues().iterator$0(); $$i.hasNext$0(); ) {
         var lib = $$i.next$0();
-        if (lib._privateMembers.containsKey(member.get$jsname())) {
+        if (lib.get$_privateMembers().containsKey$1(member.get$jsname())) {
           member._jsname = ('_' + this.get$jsname() + member.get$jsname());
           break;
         }
       }
-      mset = new MemberSet(member, false);
+      mset = new MemberSet(member, true);
       this._privateMembers.$setindex(member.name, mset);
     }
     else {
       mset.get$members().add$1(member);
     }
   }
   else {
     $globals.world._addMember(member);
   }
 }
@@ skipping 521 matching lines @@
     return ('' + prefix + 'factory');
   }
   else {
     return ('' + prefix + this.name + '\$factory');
   }
 }
 Member.prototype.hashCode = function() {
   return (this.declaringType.hashCode() << 4) ^ this.name.hashCode();
 }
 Member.prototype._get$3 = Member.prototype._get;
+Member.prototype._get$3$isDynamic = Member.prototype._get;
+Member.prototype._get$4 = Member.prototype._get;
 Member.prototype._set$4 = Member.prototype._set;
+Member.prototype._set$4$isDynamic = Member.prototype._set;
+Member.prototype._set$5 = Member.prototype._set;
 Member.prototype.canInvoke$2 = Member.prototype.canInvoke;
 Member.prototype.computeValue$0 = Member.prototype.computeValue;
 Member.prototype.hashCode$0 = Member.prototype.hashCode;
 Member.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 Member.prototype.invoke$4$isDynamic = Member.prototype.invoke;
 Member.prototype.invoke$5 = Member.prototype.invoke;
 Member.prototype.provideFieldSyntax$0 = Member.prototype.provideFieldSyntax;
 Member.prototype.providePropertySyntax$0 = Member.prototype.providePropertySyntax;
@@ skipping 31 matching lines @@
 }
 TypeMember.prototype._set = function(context, node, target, value, isDynamic) {
   $globals.world.error('cannot set type', node.span);
 }
 TypeMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   $globals.world.error('cannot invoke type', node.span);
 }
 TypeMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
 };
+TypeMember.prototype._get$3$isDynamic = TypeMember.prototype._get;
+TypeMember.prototype._get$4 = TypeMember.prototype._get;
 TypeMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
+TypeMember.prototype._set$4$isDynamic = TypeMember.prototype._set;
+TypeMember.prototype._set$5 = TypeMember.prototype._set;
 TypeMember.prototype.canInvoke$2 = TypeMember.prototype.canInvoke;
 TypeMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 TypeMember.prototype.invoke$4$isDynamic = TypeMember.prototype.invoke;
 TypeMember.prototype.invoke$5 = TypeMember.prototype.invoke;
 // ********** Code for FieldMember **************
 function FieldMember(name, declaringType, definition, value) {
   this._providePropertySyntax = false
   this._computing = false
@@ skipping 158 matching lines @@
   return new Value(this.type, ('' + target.code + '.' + this.get$jsname()), node.span, true);
 }
 FieldMember.prototype._set = function(context, node, target, value, isDynamic) {
   var lhs = this._get(context, node, target, isDynamic);
   value = value.convertTo(context, this.type, node, isDynamic);
   return new Value(this.type, ('' + lhs.get$code() + ' = ' + value.code), node.span, true);
 }
 FieldMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
 };
+FieldMember.prototype._get$3$isDynamic = FieldMember.prototype._get;
+FieldMember.prototype._get$4 = FieldMember.prototype._get;
 FieldMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
+FieldMember.prototype._set$4$isDynamic = FieldMember.prototype._set;
+FieldMember.prototype._set$5 = FieldMember.prototype._set;
 FieldMember.prototype.computeValue$0 = FieldMember.prototype.computeValue;
 FieldMember.prototype.provideFieldSyntax$0 = FieldMember.prototype.provideFieldSyntax;
 FieldMember.prototype.providePropertySyntax$0 = FieldMember.prototype.providePropertySyntax;
 FieldMember.prototype.resolve$0 = FieldMember.prototype.resolve;
 // ********** Code for PropertyMember **************
 function PropertyMember(name, declaringType) {
   this._provideFieldSyntax = false
   // Initializers done
   Member.call(this, name, declaringType);
 }
@@ skipping 75 matching lines @@
   if (this.setter == null) this.setter = parent.setter;
 }
 PropertyMember.prototype.resolve = function() {
   if (this.getter != null) this.getter.resolve();
   if (this.setter != null) this.setter.resolve();
   this.get$library()._addMember(this);
 }
 PropertyMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
 };
+PropertyMember.prototype._get$3$isDynamic = PropertyMember.prototype._get;
+PropertyMember.prototype._get$4 = PropertyMember.prototype._get;
 PropertyMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
+PropertyMember.prototype._set$4$isDynamic = PropertyMember.prototype._set;
+PropertyMember.prototype._set$5 = PropertyMember.prototype._set;
 PropertyMember.prototype.provideFieldSyntax$0 = PropertyMember.prototype.provideFieldSyntax;
 PropertyMember.prototype.providePropertySyntax$0 = PropertyMember.prototype.providePropertySyntax;
 PropertyMember.prototype.resolve$0 = PropertyMember.prototype.resolve;
 // ********** Code for ConcreteMember **************
 function ConcreteMember(name, declaringType, baseMember) {
   this.baseMember = baseMember;
   // Initializers done
   Member.call(this, name, declaringType);
   this.parameters = [];
   this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType);
@@ skipping 108 matching lines @@
     code = code.replaceFirst$2(this.declaringType.get$genericType().get$jsname(), this.declaringType.get$jsname());
   }
   if ((this.baseMember instanceof MethodMember)) {
     this.declaringType.genMethod(this);
   }
   return new Value(this.get$inferredResult(), code, node.span, true);
 }
 ConcreteMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
 };
+ConcreteMember.prototype._get$3$isDynamic = ConcreteMember.prototype._get;
+ConcreteMember.prototype._get$4 = ConcreteMember.prototype._get;
 ConcreteMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
+ConcreteMember.prototype._set$4$isDynamic = ConcreteMember.prototype._set;
+ConcreteMember.prototype._set$5 = ConcreteMember.prototype._set;
 ConcreteMember.prototype.canInvoke$2 = ConcreteMember.prototype.canInvoke;
 ConcreteMember.prototype.computeValue$0 = ConcreteMember.prototype.computeValue;
 ConcreteMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 ConcreteMember.prototype.invoke$4$isDynamic = ConcreteMember.prototype.invoke;
 ConcreteMember.prototype.invoke$5 = ConcreteMember.prototype.invoke;
 ConcreteMember.prototype.provideFieldSyntax$0 = ConcreteMember.prototype.provideFieldSyntax;
 ConcreteMember.prototype.providePropertySyntax$0 = ConcreteMember.prototype.providePropertySyntax;
 // ********** Code for MethodMember **************
@@ skipping 699 matching lines @@
     param.resolve$0();
     this.parameters.add(param);
   }
   if (!this.isLambda) {
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
 };
+MethodMember.prototype._get$3$isDynamic = MethodMember.prototype._get;
+MethodMember.prototype._get$4 = MethodMember.prototype._get;
 MethodMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
+MethodMember.prototype._set$4$isDynamic = MethodMember.prototype._set;
+MethodMember.prototype._set$5 = MethodMember.prototype._set;
 MethodMember.prototype.canInvoke$2 = MethodMember.prototype.canInvoke;
 MethodMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 MethodMember.prototype.invoke$4$isDynamic = MethodMember.prototype.invoke;
 MethodMember.prototype.invoke$5 = MethodMember.prototype.invoke;
 MethodMember.prototype.namesInOrder$1 = MethodMember.prototype.namesInOrder;
 MethodMember.prototype.provideFieldSyntax$0 = MethodMember.prototype.provideFieldSyntax;
 MethodMember.prototype.providePropertySyntax$0 = MethodMember.prototype.providePropertySyntax;
 MethodMember.prototype.resolve$0 = MethodMember.prototype.resolve;
@@ skipping 67 matching lines @@
   return this._treatAsField;
 }
 MemberSet.prototype._get = function(context, node, target, isDynamic) {
   var returnValue;
   var targets = this.members.filter((function (m) {
     return m.get$canGet();
   })
   );
   if (this.isVar) {
     targets.forEach$1((function (m) {
-      return m._get(context, node, target, true);
+      return m._get$3$isDynamic(context, node, target, true);
     })
     );
     returnValue = new Value(this._foldTypes(targets), null, node.span, true);
   }
   else {
     if (this.members.length == 1) {
-      return this.members.$index(0)._get(context, node, target, isDynamic);
+      return this.members.$index(0)._get$4(context, node, target, isDynamic);
     }
     else if ($eq(targets.length, 1)) {
-      return targets.$index(0)._get(context, node, target, isDynamic);
+      return targets.$index(0)._get$4(context, node, target, isDynamic);
     }
     for (var $$i = targets.iterator$0(); $$i.hasNext$0(); ) {
       var member = $$i.next$0();
-      var value = member._get(context, node, target, true);
+      var value = member._get$3$isDynamic(context, node, target, true);
       returnValue = this._tryUnion(returnValue, value, node);
     }
     if (returnValue == null) {
       return this._makeError(node, target, 'getter');
     }
   }
   if (returnValue.code == null) {
     if (this.get$treatAsField()) {
       return new Value(returnValue.get$type(), ('' + target.code + '.' + this.jsname), node.span, true);
     }
     else {
       return new Value(returnValue.get$type(), ('' + target.code + '.get\$' + this.jsname + '()'), node.span, true);
     }
   }
   return returnValue;
 }
 MemberSet.prototype._set = function(context, node, target, value, isDynamic) {
   var returnValue;
   var targets = this.members.filter((function (m) {
     return m.get$canSet();
   })
   );
   if (this.isVar) {
     targets.forEach$1((function (m) {
-      return m._set(context, node, target, value, true);
+      return m._set$4$isDynamic(context, node, target, value, true);
     })
     );
     returnValue = new Value(this._foldTypes(targets), null, node.span, true);
   }
   else {
     if (this.members.length == 1) {
-      return this.members.$index(0)._set(context, node, target, value, isDynamic);
+      return this.members.$index(0)._set$5(context, node, target, value, isDynamic);
     }
     else if ($eq(targets.length, 1)) {
-      return targets.$index(0)._set(context, node, target, value, isDynamic);
+      return targets.$index(0)._set$5(context, node, target, value, isDynamic);
     }
     for (var $$i = targets.iterator$0(); $$i.hasNext$0(); ) {
       var member = $$i.next$0();
-      var res = member._set(context, node, target, value, true);
+      var res = member._set$4$isDynamic(context, node, target, value, true);
       returnValue = this._tryUnion(returnValue, res, node);
     }
     if (returnValue == null) {
       return this._makeError(node, target, 'setter');
     }
   }
   if (returnValue.code == null) {
     if (this.get$treatAsField()) {
       return new Value(returnValue.get$type(), ('' + target.code + '.' + this.jsname + ' = ' + value.code), node.span, true);
     }
@@ skipping 95 matching lines @@
 }
 MemberSet.prototype._foldTypes = function(targets) {
   return reduce(map(targets, (function (t) {
     return t.get$returnType();
   })
   ), Type.union, $globals.world.varType);
 }
 MemberSet.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
 };
+MemberSet.prototype._get$3$isDynamic = MemberSet.prototype._get;
+MemberSet.prototype._get$4 = MemberSet.prototype._get;
 MemberSet.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
+MemberSet.prototype._set$4$isDynamic = MemberSet.prototype._set;
+MemberSet.prototype._set$5 = MemberSet.prototype._set;
 MemberSet.prototype.add$1 = MemberSet.prototype.add;
 MemberSet.prototype.canInvoke$2 = MemberSet.prototype.canInvoke;
 MemberSet.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 MemberSet.prototype.invoke$4$isDynamic = MemberSet.prototype.invoke;
 MemberSet.prototype.invoke$5 = MemberSet.prototype.invoke;
 MemberSet.prototype.toString$0 = MemberSet.prototype.toString;
 // ********** Code for FactoryMap **************
 function FactoryMap() {
@@ skipping 4436 matching lines @@
       var typeArg = args.next$0();
       if ($ne(typeParam.get$extendsType(), null) && $ne(typeArg, null)) {
         typeArg.ensureSubtypeOf$3(typeParam.get$extendsType(), typeParam.get$span(), true);
       }
     }
   }
   if (this.get$interfaces() != null) {
     var $$list = this.get$interfaces();
     for (var $$i = 0;$$i < $$list.length; $$i++) {
       var i = $$list.$index($$i);
-      i._checkExtends();
+      i._checkExtends$0();
     }
   }
 }
 Type.prototype._checkOverride = function(member) {
   var parentMember = this._getMemberInParents(member.name);
   if ($ne(parentMember, null)) {
     if (!member.get$isPrivate() || $eq(member.get$library(), parentMember.get$library())) {
       member.override(parentMember);
     }
   }
@@ skipping 162 matching lines @@
   if (tp.length < sp.length) return false;
   for (var i = 0;
    i < sp.length; i++) {
     if ($ne(tp.$index(i).get$isOptional(), sp.$index(i).get$isOptional())) return false;
     if (tp.$index(i).get$isOptional() && $ne(tp.$index(i).get$name(), sp.$index(i).get$name())) return false;
     if (!tp.$index(i).get$type().isAssignable$1(sp.$index(i).get$type())) return false;
   }
   if (tp.length > sp.length && !tp.$index(sp.length).get$isOptional()) return false;
   return true;
 }
+Type.prototype._checkExtends$0 = Type.prototype._checkExtends;
 Type.prototype.addDirectSubtype$1 = Type.prototype.addDirectSubtype;
 Type.prototype.ensureSubtypeOf$3 = Type.prototype.ensureSubtypeOf;
 Type.prototype.getConstructor$1 = Type.prototype.getConstructor;
 Type.prototype.getFactory$2 = Type.prototype.getFactory;
 Type.prototype.getMember$1 = Type.prototype.getMember;
 Type.prototype.getOrMakeConcreteType$1 = Type.prototype.getOrMakeConcreteType;
 Type.prototype.isAssignable$1 = Type.prototype.isAssignable;
 Type.prototype.isSubtypeOf$1 = Type.prototype.isSubtypeOf;
 Type.prototype.markUsed$0 = Type.prototype.markUsed;
 Type.prototype.resolveTypeParams$1 = Type.prototype.resolveTypeParams;
@@ skipping 177 matching lines @@
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
   this.constructors = new HashMapImplementation();
   this.members = new HashMapImplementation();
   this.factories = new FactoryMap();
   // Initializers done
   Type.call(this, name);
 }
 $inherits(ConcreteType, Type);
 ConcreteType.prototype.get$genericType = function() { return this.genericType; };
+ConcreteType.prototype.get$_parent = function() { return this._parent; };
+ConcreteType.prototype.set$_parent = function(value) { return this._parent = value; };
 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.isClass;
 }
 ConcreteType.prototype.get$library = function() {
   return this.genericType.library;
@@ skipping 150 matching lines @@
   this.factories = new FactoryMap();
   // Initializers done
   Type.call(this, name);
   this.setDefinition(definition);
 }
 $inherits(DefinedType, Type);
 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$parent = function() {
   return this._parent;
 }
 DefinedType.prototype.set$parent = function(p) {
   this._parent = p;
 }
 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$_concreteTypes = function() { return this._concreteTypes; };
+DefinedType.prototype.set$_concreteTypes = function(value) { return this._concreteTypes = value; };
 DefinedType.prototype.get$isUsed = function() { return this.isUsed; };
 DefinedType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
 DefinedType.prototype.get$isNative = function() { return this.isNative; };
 DefinedType.prototype.set$isNative = function(value) { return this.isNative = value; };
 DefinedType.prototype.setDefinition = function(def) {
   this.definition = def;
   if ((this.definition instanceof TypeDefinition) && $ne(this.definition.get$nativeType(), null)) {
     this.isNative = true;
   }
   if (this.definition != null && $ne(this.definition.get$typeParameters(), null)) {
@@ skipping 373 matching lines @@
     typeMap.$setindex(paramName, typeArgs.$index(i));
     names.add$1(typeArgs.$index(i).get$name());
     jsnames.add$1(typeArgs.$index(i).get$jsname());
   }
   var jsname = ('' + this.get$jsname() + '_' + Strings.join(jsnames, '\$'));
   var simpleName = ('' + this.name + '<' + Strings.join(names, ', ') + '>');
   var key = Strings.join(names, '\$');
   var ret = this._concreteTypes.$index(key);
   if (ret == null) {
     ret = new ConcreteType(simpleName, this, typeMap, typeArgs);
-    ret._jsname = jsname;
+    ret.set$_jsname(jsname);
     this._concreteTypes.$setindex(key, ret);
   }
   return ret;
 }
 DefinedType.prototype.getCallStub = function(args) {
   var name = _getCallStubName('call', args);
   var stub = this.varStubs.$index(name);
   if (stub == null) {
     stub = new VarFunctionStub(name, args);
     this.varStubs.$setindex(name, stub);
@@ skipping 166 matching lines @@
   if ($ne(member, null)) {
     return member._get$3(context, node, this);
   }
   else {
     return this.invokeNoSuchMethod(context, ('get:' + name), node);
   }
 }
 Value.prototype.set_ = function(context, name, node, value, isDynamic) {
   var member = this._resolveMember(context, name, node, isDynamic);
   if ($ne(member, null)) {
-    return member._set(context, node, this, value, isDynamic);
+    return member._set$5(context, node, this, value, isDynamic);
   }
   else {
     return this.invokeNoSuchMethod(context, ('set:' + name), node, new Arguments(null, [value]));
   }
 }
 Value.prototype.invoke = function(context, name, node, args, isDynamic) {
   if (this.get$_typeIsVarOrParameterType() && name == ':ne') {
     if (args.values.length != 1) {
       $globals.world.warning('wrong number of arguments for !=', node.span);
     }
@@ skipping 111 matching lines @@
   var callMethod = toType.getCallMethod();
   if ($ne(callMethod, null)) {
     if (checked && !toType.isAssignable(this.get$type())) {
       this.convertWarning(toType, node);
     }
     var arity = callMethod.get$parameters().length;
     var myCall = this.get$type().getCallMethod();
     if (myCall == null || $ne(myCall.get$parameters().length, arity)) {
       var stub = $globals.world.functionType.getCallStub(Arguments.Arguments$bare$factory(arity));
       var val = new Value(toType, ('to\$' + stub.name + '(' + this.code + ')'), node.span, true);
-      return this._isDomCallback(toType) && !this._isDomCallback(this.get$type()) ? val._wrapDomCallback(toType, arity) : val;
+      return this._isDomCallback(toType) && !this._isDomCallback(this.get$type()) ? val._wrapDomCallback$2(toType, arity) : val;
     }
     else if (this._isDomCallback(toType) && !this._isDomCallback(this.get$type())) {
       return this._wrapDomCallback(toType, arity);
     }
   }
   var fromType = this.get$type();
   if (this.get$type().get$isVar() && (this.code != 'null' || !toType.get$isNullable())) {
     fromType = $globals.world.objectType;
   }
   var bothNum = this.get$type().get$isNum() && toType.get$isNum();
@@ skipping 126 matching lines @@
     var argsCode = [];
     for (var i = 0;
      i < args.get$length(); i++) {
       argsCode.add$1(args.values.$index(i).get$code());
     }
     pos = Strings.join(argsCode, ", ");
   }
   var noSuchArgs = [new Value($globals.world.stringType, ('"' + name + '"'), node.span, true), new Value($globals.world.listType, ('[' + pos + ']'), node.span, true)];
   return this._resolveMember(context, 'noSuchMethod', node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs));
 }
+Value.prototype._wrapDomCallback$2 = Value.prototype._wrapDomCallback;
 Value.prototype.checkFirstClass$1 = Value.prototype.checkFirstClass;
 Value.prototype.convertTo$3 = function($0, $1, $2) {
   return this.convertTo($0, $1, $2, false);
 };
 Value.prototype.convertTo$4 = Value.prototype.convertTo;
 Value.prototype.get_$3 = Value.prototype.get_;
 Value.prototype.instanceOf$3$isTrue$forceCheck = Value.prototype.instanceOf;
 Value.prototype.instanceOf$4 = function($0, $1, $2, $3) {
   return this.instanceOf($0, $1, $2, $3, false);
 };
@@ skipping 1031 matching lines @@
 $inheritsMembers(_DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V, DoubleLinkedQueueEntry_KeyValuePair_K$V);
 //  ********** Globals **************
 function $static_init(){
 }
 var const$0 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 var const$2 = new EmptyQueueException()/*const EmptyQueueException()*/;
 var const$3 = new _DeletedKeySentinel()/*const _DeletedKeySentinel()*/;
 var $globals = {};
 $static_init();
 main();