cleanup resolveMember and get/set

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 function $throw(e) {
   // If e is not a value, we can use V8's captureStackTrace utility method.
   // TODO(jmesserly): capture the stack trace on other JS engines.
   if (e && (typeof e == 'object') && Error.captureStackTrace) {
     // TODO(jmesserly): this will clobber the e.stack property
     Error.captureStackTrace(e, $throw);
   }
@@ skipping 72 matching lines @@
   }
 }
 // ********** Code for Object **************
 Object.defineProperty(Object.prototype, "get$dynamic", { value: function() {
   "use strict"; return this;
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "noSuchMethod", { value: function(name, args) {
   $throw(new NoSuchMethodException(this, name, args));
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_asNonSentinelEntry$0", { value: function() {
-  return this.noSuchMethod("_asNonSentinelEntry", []);
+  return this.noSuchMethod$2("_asNonSentinelEntry", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_checkExtends$0", { value: function() {
-  return this.noSuchMethod("_checkExtends", []);
+  return this.noSuchMethod$2("_checkExtends", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_checkNonStatic$1", { value: function($0) {
-  return this.noSuchMethod("_checkNonStatic", [$0]);
+  return this.noSuchMethod$2("_checkNonStatic", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_evalConstConstructor$2", { value: function($0, $1) {
-  return this.noSuchMethod("_evalConstConstructor", [$0, $1]);
+  return this.noSuchMethod$2("_evalConstConstructor", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_get$3", { value: function($0, $1, $2) {
-  return this.noSuchMethod("_get", [$0, $1, $2]);
+  return this.noSuchMethod$2("_get", [$0, $1, $2]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_get$3$isDynamic", { value: function($0, $1, $2, isDynamic) {
-  return this.noSuchMethod("_get", [$0, $1, $2, isDynamic]);
+  return this.noSuchMethod$2("_get", [$0, $1, $2, isDynamic]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_get$4", { value: function($0, $1, $2, $3) {
-  return this.noSuchMethod("_get", [$0, $1, $2, $3]);
+  return this.noSuchMethod$2("_get", [$0, $1, $2, $3]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_pushBlock$1", { value: function($0) {
-  return this.noSuchMethod("_pushBlock", [$0]);
-}, enumerable: false, writable: true, configurable: true });
-Object.defineProperty(Object.prototype, "_set$4", { value: function($0, $1, $2, $3) {
-  return this.noSuchMethod("_set", [$0, $1, $2, $3]);
+  return this.noSuchMethod$2("_pushBlock", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_set$4$isDynamic", { value: function($0, $1, $2, $3, isDynamic) {
-  return this.noSuchMethod("_set", [$0, $1, $2, $3, isDynamic]);
+  return this.noSuchMethod$2("_set", [$0, $1, $2, $3, isDynamic]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_set$5", { value: function($0, $1, $2, $3, $4) {
-  return this.noSuchMethod("_set", [$0, $1, $2, $3, $4]);
+  return this.noSuchMethod$2("_set", [$0, $1, $2, $3, $4]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_setindex$2", { value: function($0, $1) {
-  return this.noSuchMethod("_setindex", [$0, $1]);
+  return this.noSuchMethod$2("_setindex", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "add$1", { value: function($0) {
-  return this.noSuchMethod("add", [$0]);
+  return this.noSuchMethod$2("add", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "addAll$1", { value: function($0) {
-  return this.noSuchMethod("addAll", [$0]);
+  return this.noSuchMethod$2("addAll", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "addDirectSubtype$1", { value: function($0) {
-  return this.noSuchMethod("addDirectSubtype", [$0]);
+  return this.noSuchMethod$2("addDirectSubtype", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "addLast$1", { value: function($0) {
-  return this.noSuchMethod("addLast", [$0]);
+  return this.noSuchMethod$2("addLast", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "addMethod$2", { value: function($0, $1) {
-  return this.noSuchMethod("addMethod", [$0, $1]);
+  return this.noSuchMethod$2("addMethod", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "addSource$1", { value: function($0) {
-  return this.noSuchMethod("addSource", [$0]);
+  return this.noSuchMethod$2("addSource", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "binop$4", { value: function($0, $1, $2, $3) {
-  return this.noSuchMethod("binop", [$0, $1, $2, $3]);
+  return this.noSuchMethod$2("binop", [$0, $1, $2, $3]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "block$0", { value: function() {
-  return this.noSuchMethod("block", []);
+  return this.noSuchMethod$2("block", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "canInvoke$2", { value: function($0, $1) {
-  return this.noSuchMethod("canInvoke", [$0, $1]);
+  return this.noSuchMethod$2("canInvoke", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "checkFirstClass$1", { value: function($0) {
-  return this.noSuchMethod("checkFirstClass", [$0]);
+  return this.noSuchMethod$2("checkFirstClass", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "compareTo$1", { value: function($0) {
-  return this.noSuchMethod("compareTo", [$0]);
+  return this.noSuchMethod$2("compareTo", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "compilationUnit$0", { value: function() {
-  return this.noSuchMethod("compilationUnit", []);
+  return this.noSuchMethod$2("compilationUnit", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "computeValue$0", { value: function() {
-  return this.noSuchMethod("computeValue", []);
+  return this.noSuchMethod$2("computeValue", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "contains$1", { value: function($0) {
-  return this.noSuchMethod("contains", [$0]);
+  return this.noSuchMethod$2("contains", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "containsKey$1", { value: function($0) {
-  return this.noSuchMethod("containsKey", [$0]);
+  return this.noSuchMethod$2("containsKey", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "convertTo$2", { value: function($0, $1) {
-  return this.noSuchMethod("convertTo", [$0, $1]);
+  return this.noSuchMethod$2("convertTo", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "convertTo$3", { value: function($0, $1, $2) {
-  return this.noSuchMethod("convertTo", [$0, $1, $2]);
+  return this.noSuchMethod$2("convertTo", [$0, $1, $2]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "copyWithNewType$2", { value: function($0, $1) {
-  return this.noSuchMethod("copyWithNewType", [$0, $1]);
+  return this.noSuchMethod$2("copyWithNewType", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "create$3$isFinal", { value: function($0, $1, $2, isFinal) {
-  return this.noSuchMethod("create", [$0, $1, $2, isFinal]);
+  return this.noSuchMethod$2("create", [$0, $1, $2, isFinal]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "elapsedInMs$0", { value: function() {
-  return this.noSuchMethod("elapsedInMs", []);
+  return this.noSuchMethod$2("elapsedInMs", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "end$0", { value: function() {
-  return this.noSuchMethod("end", []);
+  return this.noSuchMethod$2("end", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "endsWith$1", { value: function($0) {
-  return this.noSuchMethod("endsWith", [$0]);
+  return this.noSuchMethod$2("endsWith", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "ensureSubtypeOf$3", { value: function($0, $1, $2) {
-  return this.noSuchMethod("ensureSubtypeOf", [$0, $1, $2]);
+  return this.noSuchMethod$2("ensureSubtypeOf", [$0, $1, $2]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "evalBody$2", { value: function($0, $1) {
-  return this.noSuchMethod("evalBody", [$0, $1]);
-}, enumerable: false, writable: true, configurable: true });
-Object.defineProperty(Object.prototype, "every$1", { value: function($0) {
-  return this.noSuchMethod("every", [$0]);
+  return this.noSuchMethod$2("evalBody", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "filter$1", { value: function($0) {
-  return this.noSuchMethod("filter", [$0]);
+  return this.noSuchMethod$2("filter", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "findTypeByName$1", { value: function($0) {
-  return this.noSuchMethod("findTypeByName", [$0]);
+  return this.noSuchMethod$2("findTypeByName", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "forEach$1", { value: function($0) {
-  return this.noSuchMethod("forEach", [$0]);
+  return this.noSuchMethod$2("forEach", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "genValue$2", { value: function($0, $1) {
-  return this.noSuchMethod("genValue", [$0, $1]);
+  return this.noSuchMethod$2("genValue", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "generate$1", { value: function($0) {
-  return this.noSuchMethod("generate", [$0]);
+  return this.noSuchMethod$2("generate", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getColumn$2", { value: function($0, $1) {
-  return this.noSuchMethod("getColumn", [$0, $1]);
+  return this.noSuchMethod$2("getColumn", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getConstructor$1", { value: function($0) {
-  return this.noSuchMethod("getConstructor", [$0]);
+  return this.noSuchMethod$2("getConstructor", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getFactory$2", { value: function($0, $1) {
-  return this.noSuchMethod("getFactory", [$0, $1]);
+  return this.noSuchMethod$2("getFactory", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getGlobalValue$0", { value: function() {
-  return this.noSuchMethod("getGlobalValue", []);
+  return this.noSuchMethod$2("getGlobalValue", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getKeys$0", { value: function() {
-  return this.noSuchMethod("getKeys", []);
+  return this.noSuchMethod$2("getKeys", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getLine$1", { value: function($0) {
-  return this.noSuchMethod("getLine", [$0]);
+  return this.noSuchMethod$2("getLine", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getMember$1", { value: function($0) {
-  return this.noSuchMethod("getMember", [$0]);
+  return this.noSuchMethod$2("getMember", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getOrMakeConcreteType$1", { value: function($0) {
-  return this.noSuchMethod("getOrMakeConcreteType", [$0]);
-}, enumerable: false, writable: true, configurable: true });
-Object.defineProperty(Object.prototype, "getRange$2", { value: function($0, $1) {
-  return this.noSuchMethod("getRange", [$0, $1]);
+  return this.noSuchMethod$2("getOrMakeConcreteType", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getValues$0", { value: function() {
-  return this.noSuchMethod("getValues", []);
+  return this.noSuchMethod$2("getValues", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "get_$3", { value: function($0, $1, $2) {
-  return this.noSuchMethod("get_", [$0, $1, $2]);
+  return this.noSuchMethod$2("get_", [$0, $1, $2]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "hasNext$0", { value: function() {
-  return this.noSuchMethod("hasNext", []);
+  return this.noSuchMethod$2("hasNext", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "hashCode$0", { value: function() {
-  return this.noSuchMethod("hashCode", []);
+  return this.noSuchMethod$2("hashCode", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "indexOf$1", { value: function($0) {
-  return this.noSuchMethod("indexOf", [$0]);
+  return this.noSuchMethod$2("indexOf", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "initFields$0", { value: function() {
-  return this.noSuchMethod("initFields", []);
+  return this.noSuchMethod$2("initFields", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "instanceOf$3$isTrue$forceCheck", { value: function($0, $1, $2, isTrue, forceCheck) {
-  return this.noSuchMethod("instanceOf", [$0, $1, $2, isTrue, forceCheck]);
+  return this.noSuchMethod$2("instanceOf", [$0, $1, $2, isTrue, forceCheck]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "instanceOf$4", { value: function($0, $1, $2, $3) {
-  return this.noSuchMethod("instanceOf", [$0, $1, $2, $3]);
+  return this.noSuchMethod$2("instanceOf", [$0, $1, $2, $3]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "invoke$4", { value: function($0, $1, $2, $3) {
-  return this.noSuchMethod("invoke", [$0, $1, $2, $3]);
+  return this.noSuchMethod$2("invoke", [$0, $1, $2, $3]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "invoke$4$isDynamic", { value: function($0, $1, $2, $3, isDynamic) {
-  return this.noSuchMethod("invoke", [$0, $1, $2, $3, isDynamic]);
+  return this.noSuchMethod$2("invoke", [$0, $1, $2, $3, isDynamic]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "invoke$5", { value: function($0, $1, $2, $3, $4) {
-  return this.noSuchMethod("invoke", [$0, $1, $2, $3, $4]);
+  return this.noSuchMethod$2("invoke", [$0, $1, $2, $3, $4]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "invokeNoSuchMethod$4", { value: function($0, $1, $2, $3) {
-  return this.noSuchMethod("invokeNoSuchMethod", [$0, $1, $2, $3]);
+  return this.noSuchMethod$2("invokeNoSuchMethod", [$0, $1, $2, $3]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "is$List", { value: function() {
   return false;
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "is$RegExp", { value: function() {
   return false;
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "isAssignable$1", { value: function($0) {
-  return this.noSuchMethod("isAssignable", [$0]);
+  return this.noSuchMethod$2("isAssignable", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "isEmpty$0", { value: function() {
-  return this.noSuchMethod("isEmpty", []);
+  return this.noSuchMethod$2("isEmpty", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "isSubtypeOf$1", { value: function($0) {
-  return this.noSuchMethod("isSubtypeOf", [$0]);
+  return this.noSuchMethod$2("isSubtypeOf", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "iterator$0", { value: function() {
-  return this.noSuchMethod("iterator", []);
+  return this.noSuchMethod$2("iterator", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "last$0", { value: function() {
-  return this.noSuchMethod("last", []);
+  return this.noSuchMethod$2("last", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "lookup$2", { value: function($0, $1) {
-  return this.noSuchMethod("lookup", [$0, $1]);
+  return this.noSuchMethod$2("lookup", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "markUsed$0", { value: function() {
-  return this.noSuchMethod("markUsed", []);
+  return this.noSuchMethod$2("markUsed", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "namesInOrder$1", { value: function($0) {
-  return this.noSuchMethod("namesInOrder", [$0]);
+  return this.noSuchMethod$2("namesInOrder", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "needsConversion$1", { value: function($0) {
-  return this.noSuchMethod("needsConversion", [$0]);
+  return this.noSuchMethod$2("needsConversion", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "next$0", { value: function() {
-  return this.noSuchMethod("next", []);
+  return this.noSuchMethod$2("next", []);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "noSuchMethod$2", { value: function($0, $1) {
+  return this.noSuchMethod($0, $1);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "postResolveChecks$0", { value: function() {
-  return this.noSuchMethod("postResolveChecks", []);
+  return this.noSuchMethod$2("postResolveChecks", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "provideFieldSyntax$0", { value: function() {
-  return this.noSuchMethod("provideFieldSyntax", []);
+  return this.noSuchMethod$2("provideFieldSyntax", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "providePropertySyntax$0", { value: function() {
-  return this.noSuchMethod("providePropertySyntax", []);
-}, enumerable: false, writable: true, configurable: true });
-Object.defineProperty(Object.prototype, "putIfAbsent$2", { value: function($0, $1) {
-  return this.noSuchMethod("putIfAbsent", [$0, $1]);
-}, enumerable: false, writable: true, configurable: true });
-Object.defineProperty(Object.prototype, "removeFirst$0", { value: function() {
-  return this.noSuchMethod("removeFirst", []);
+  return this.noSuchMethod$2("providePropertySyntax", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "removeLast$0", { value: function() {
-  return this.noSuchMethod("removeLast", []);
+  return this.noSuchMethod$2("removeLast", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "replaceFirst$2", { value: function($0, $1) {
-  return this.noSuchMethod("replaceFirst", [$0, $1]);
+  return this.noSuchMethod$2("replaceFirst", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "replaceValue$1", { value: function($0) {
-  return this.noSuchMethod("replaceValue", [$0]);
+  return this.noSuchMethod$2("replaceValue", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "resolve$0", { value: function() {
-  return this.noSuchMethod("resolve", []);
+  return this.noSuchMethod$2("resolve", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "resolveType$2", { value: function($0, $1) {
-  return this.noSuchMethod("resolveType", [$0, $1]);
+  return this.noSuchMethod$2("resolveType", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "resolveTypeParams$1", { value: function($0) {
-  return this.noSuchMethod("resolveTypeParams", [$0]);
+  return this.noSuchMethod$2("resolveTypeParams", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "run$0", { value: function() {
-  return this.noSuchMethod("run", []);
+  return this.noSuchMethod$2("run", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "setDefinition$1", { value: function($0) {
-  return this.noSuchMethod("setDefinition", [$0]);
+  return this.noSuchMethod$2("setDefinition", [$0]);
 }, enumerable: false, writable: true, configurable: true });
-Object.defineProperty(Object.prototype, "set_$4", { value: function($0, $1, $2, $3) {
-  return this.noSuchMethod("set_", [$0, $1, $2, $3]);
+Object.defineProperty(Object.prototype, "setIndex$4$kind$returnKind", { value: function($0, $1, $2, $3, kind, returnKind) {
+  return this.noSuchMethod$2("setIndex", [$0, $1, $2, $3, kind, returnKind]);
 }, enumerable: false, writable: true, configurable: true });
-Object.defineProperty(Object.prototype, "some$1", { value: function($0) {
-  return this.noSuchMethod("some", [$0]);
+Object.defineProperty(Object.prototype, "set_$4$kind$returnKind", { value: function($0, $1, $2, $3, kind, returnKind) {
+  return this.noSuchMethod$2("set_", [$0, $1, $2, $3, kind, returnKind]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "sort$1", { value: function($0) {
-  return this.noSuchMethod("sort", [$0]);
+  return this.noSuchMethod$2("sort", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "start$0", { value: function() {
-  return this.noSuchMethod("start", []);
+  return this.noSuchMethod$2("start", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "startsWith$1", { value: function($0) {
-  return this.noSuchMethod("startsWith", [$0]);
+  return this.noSuchMethod$2("startsWith", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "stop$0", { value: function() {
-  return this.noSuchMethod("stop", []);
+  return this.noSuchMethod$2("stop", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "substring$1", { value: function($0) {
-  return this.noSuchMethod("substring", [$0]);
+  return this.noSuchMethod$2("substring", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "substring$2", { value: function($0, $1) {
-  return this.noSuchMethod("substring", [$0, $1]);
+  return this.noSuchMethod$2("substring", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "toRadixString$1", { value: function($0) {
-  return this.noSuchMethod("toRadixString", [$0]);
+  return this.noSuchMethod$2("toRadixString", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "toString$0", { value: function() {
   return this.toString();
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "unop$3", { value: function($0, $1, $2) {
-  return this.noSuchMethod("unop", [$0, $1, $2]);
+  return this.noSuchMethod$2("unop", [$0, $1, $2]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "visit$1", { value: function($0) {
-  return this.noSuchMethod("visit", [$0]);
+  return this.noSuchMethod$2("visit", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitAssertStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitAssertStatement", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "visitBinaryExpression$1", { value: function($0) {
-  return this.noSuchMethod("visitBinaryExpression", [$0]);
+  return this.noSuchMethod$2("visitBinaryExpression", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitBlockStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitBlockStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitBreakStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitBreakStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitContinueStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitContinueStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitDeclaredIdentifier$1", { value: function($0) {
+  return this.noSuchMethod$2("visitDeclaredIdentifier", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitDietStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitDietStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitDoStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitDoStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitEmptyStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitEmptyStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitExpressionStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitExpressionStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitForInStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitForInStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitForStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitForStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitFunctionDefinition$1", { value: function($0) {
+  return this.noSuchMethod$2("visitFunctionDefinition", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitIfStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitIfStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitIndexExpression$1", { value: function($0) {
+  return this.noSuchMethod$2("visitIndexExpression", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitLabeledStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitLabeledStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitLambdaExpression$1", { value: function($0) {
+  return this.noSuchMethod$2("visitLambdaExpression", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitLiteralExpression$1", { value: function($0) {
+  return this.noSuchMethod$2("visitLiteralExpression", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitMapExpression$1", { value: function($0) {
+  return this.noSuchMethod$2("visitMapExpression", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitNewExpression$1", { value: function($0) {
+  return this.noSuchMethod$2("visitNewExpression", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "visitPostfixExpression$1", { value: function($0) {
-  return this.noSuchMethod("visitPostfixExpression", [$0]);
+  return this.noSuchMethod$2("visitPostfixExpression", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitReturnStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitReturnStatement", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "visitSources$0", { value: function() {
-  return this.noSuchMethod("visitSources", []);
+  return this.noSuchMethod$2("visitSources", []);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitSwitchStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitSwitchStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitThrowStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitThrowStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitTryStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitTryStatement", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitVariableDefinition$1", { value: function($0) {
+  return this.noSuchMethod$2("visitVariableDefinition", [$0]);
+}, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "visitWhileStatement$1", { value: function($0) {
+  return this.noSuchMethod$2("visitWhileStatement", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "write$1", { value: function($0) {
-  return this.noSuchMethod("write", [$0]);
+  return this.noSuchMethod$2("write", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "writeDefinition$2", { value: function($0, $1) {
-  return this.noSuchMethod("writeDefinition", [$0, $1]);
+  return this.noSuchMethod$2("writeDefinition", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
 // ********** Code for Clock **************
 function Clock() {}
 Clock.now = function() {
   return new Date().getTime();
 }
 Clock.frequency = function() {
   return (1000);
 }
 // ********** Code for IllegalAccessException **************
@@ skipping 10 matching lines @@
   this._functionName = _functionName;
   this._arguments = _arguments;
 }
 NoSuchMethodException.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   for (var i = (0);
    i < this._arguments.get$length(); i++) {
     if (i > (0)) {
       sb.add(", ");
     }
-    sb.add(this._arguments.$index(i));
+    sb.add(this._arguments[i]);
   }
   sb.add("]");
   return ("NoSuchMethodException - receiver: '" + this._receiver + "' ") + ("function name: '" + this._functionName + "' arguments: [" + sb + "]");
 }
 NoSuchMethodException.prototype.toString$0 = NoSuchMethodException.prototype.toString;
 // ********** Code for ClosureArgumentMismatchException **************
 function ClosureArgumentMismatchException() {
 
 }
 ClosureArgumentMismatchException.prototype.toString = function() {
@@ skipping 209 matching lines @@
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "isEmpty", { value: function() {
   return this.get$length() == (0);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "iterator", { value: function() {
   return new ListIterator(this);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "add$1", { value: ListFactory.prototype.add, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "addAll$1", { value: ListFactory.prototype.addAll, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "addLast$1", { value: ListFactory.prototype.addLast, enumerable: false, writable: true, configurable: true });
-Object.defineProperty(ListFactory.prototype, "every$1", { value: function($0) {
-  return this.every(to$call$1($0));
-}, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "filter$1", { value: function($0) {
   return this.filter(to$call$1($0));
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "forEach$1", { value: function($0) {
   return this.forEach(to$call$1($0));
 }, enumerable: false, writable: true, configurable: true });
-Object.defineProperty(ListFactory.prototype, "getRange$2", { value: ListFactory.prototype.getRange, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "indexOf$1", { value: ListFactory.prototype.indexOf, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "isEmpty$0", { value: ListFactory.prototype.isEmpty, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "iterator$0", { value: ListFactory.prototype.iterator, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "last$0", { value: ListFactory.prototype.last, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "removeLast$0", { value: ListFactory.prototype.removeLast, enumerable: false, writable: true, configurable: true });
-Object.defineProperty(ListFactory.prototype, "some$1", { value: function($0) {
-  return this.some(to$call$1($0));
-}, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "sort$1", { value: function($0) {
   return this.sort(to$call$2($0));
 }, enumerable: false, writable: true, configurable: true });
 ListFactory_E = ListFactory;
 ListFactory_Expression = ListFactory;
 ListFactory_K = ListFactory;
 ListFactory_dart_core_String = ListFactory;
 ListFactory_V = ListFactory;
 ListFactory_VariableValue = ListFactory;
 ListFactory_int = ListFactory;
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
   this._pos = (0);
 }
 ListIterator.prototype.hasNext = function() {
   return this._array.get$length() > this._pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$0005);
   }
-  return this._array.$index(this._pos++);
+  return this._array[this._pos++];
 }
 ListIterator.prototype.hasNext$0 = ListIterator.prototype.hasNext;
 ListIterator.prototype.next$0 = ListIterator.prototype.next;
 // ********** Code for ImmutableList **************
 /** Implements extends for Dart classes on JavaScript prototypes. */
 function $inherits(child, parent) {
   if (child.prototype.__proto__) {
     child.prototype.__proto__ = parent.prototype;
   } else {
     function tmp() {};
     tmp.prototype = parent.prototype;
     child.prototype = new tmp();
     child.prototype.constructor = child;
   }
 }
 $inherits(ImmutableList, ListFactory_E);
 function ImmutableList(length) {
   this._length = length;
   Array.call(this, length);
 }
 ImmutableList.ImmutableList$from$factory = function(other) {
   var list = new ImmutableList(other.get$length());
   for (var i = (0);
    i < other.get$length(); i++) {
-    list._setindex$2(i, other.$index(i));
+    list._setindex$2(i, other[i]);
   }
   return list;
 }
 ImmutableList.prototype.get$length = function() {
   return this._length;
 }
 ImmutableList.prototype.set$length = function(length) {
   $throw(const$0007);
 }
-Object.defineProperty(ImmutableList.prototype, "length", {
-  get: ImmutableList.prototype.get$length,
-  set: ImmutableList.prototype.set$length
-});
 ImmutableList.prototype._setindex = function(index, value) {
   return this[index] = value;
 }
 ImmutableList.prototype.$setindex = function(index, value) {
   $throw(const$0007);
 }
 ImmutableList.prototype.sort = function(compare) {
   $throw(const$0007);
 }
 ImmutableList.prototype.add = function(element) {
   $throw(const$0007);
 }
 ImmutableList.prototype.addLast = function(element) {
   $throw(const$0007);
 }
 ImmutableList.prototype.addAll = function(elements) {
   $throw(const$0007);
 }
 ImmutableList.prototype.clear = function() {
   $throw(const$0007);
 }
 ImmutableList.prototype.removeLast = function() {
   $throw(const$0007);
 }
 ImmutableList.prototype.toString = function() {
-  return ListFactory.ListFactory$from$factory(this).toString();
+  return ListFactory.ListFactory$from$factory(this).toString$0();
 }
 ImmutableList.prototype._setindex$2 = ImmutableList.prototype._setindex;
 ImmutableList.prototype.add$1 = ImmutableList.prototype.add;
 ImmutableList.prototype.addAll$1 = ImmutableList.prototype.addAll;
 ImmutableList.prototype.addLast$1 = ImmutableList.prototype.addLast;
 ImmutableList.prototype.removeLast$0 = ImmutableList.prototype.removeLast;
 ImmutableList.prototype.sort$1 = function($0) {
   return this.sort(to$call$2($0));
 };
 ImmutableList.prototype.toString$0 = ImmutableList.prototype.toString;
@@ skipping 61 matching lines @@
   );
   return result;
 }
 HashMapImplementation._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * (3)), (4));
 }
 HashMapImplementation._firstProbe = function(hashCode, length) {
   return hashCode & (length - (1));
 }
 HashMapImplementation._nextProbe = function(currentProbe, numberOfProbes, length) {
-  return (currentProbe + numberOfProbes) & (length - (1));
+  return ($add(currentProbe, numberOfProbes)) & (length - (1));
 }
 HashMapImplementation.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   var insertionIndex = (-1);
   while (true) {
-    var existingKey = this._keys.$index(hash);
+    var existingKey = this._keys[hash];
     if (existingKey == null) {
       if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < (0)) && (const$0001 == existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
-    var existingKey = this._keys.$index(hash);
+    var existingKey = this._keys[hash];
     if (existingKey == null) return (-1);
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation.prototype._ensureCapacity = function() {
-  var newNumberOfEntries = this._numberOfEntries + (1);
+  var newNumberOfEntries = $add(this._numberOfEntries, (1));
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.get$length() * (2));
     return;
   }
   var capacity = this._keys.get$length();
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if (this._numberOfDeleted > numberOfFree) {
     this._grow(this._keys.get$length());
   }
 }
 HashMapImplementation._isPowerOfTwo = function(x) {
   return ((x & (x - (1))) == (0));
 }
 HashMapImplementation.prototype._grow = function(newCapacity) {
   var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new Array(newCapacity);
   this._values = new Array(newCapacity);
   for (var i = (0);
    i < capacity; i++) {
-    var key = oldKeys.$index(i);
+    var key = oldKeys[i];
     if (key == null || key == const$0001) {
       continue;
     }
-    var value = oldValues.$index(i);
+    var value = oldValues[i];
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = (0);
 }
 HashMapImplementation.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$0001)) {
+  if ((this._keys[index] == null) || (this._keys[index] == const$0001)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation.prototype.$index = function(key) {
   var index = this._probeForLookup(key);
   if (index < (0)) return null;
-  return this._values.$index(index);
+  return this._values[index];
 }
 HashMapImplementation.prototype.putIfAbsent = function(key, ifAbsent) {
   var index = this._probeForLookup(key);
-  if (index >= (0)) return this._values.$index(index);
-  var value = ifAbsent();
+  if (index >= (0)) return this._values[index];
+  var value = ifAbsent.call$0();
   this.$setindex(key, value);
   return value;
 }
-HashMapImplementation.prototype.remove = function(key) {
-  var index = this._probeForLookup(key);
-  if (index >= (0)) {
-    this._numberOfEntries--;
-    var value = this._values.$index(index);
-    this._values.$setindex(index);
-    this._keys.$setindex(index, const$0001);
-    this._numberOfDeleted++;
-    return value;
-  }
-  return null;
-}
 HashMapImplementation.prototype.isEmpty = function() {
   return this._numberOfEntries == (0);
 }
 HashMapImplementation.prototype.get$length = function() {
   return this._numberOfEntries;
 }
 HashMapImplementation.prototype.forEach = function(f) {
   var length = this._keys.get$length();
   for (var i = (0);
    i < length; i++) {
-    if ((this._keys.$index(i) != null) && (this._keys.$index(i) != const$0001)) {
-      f(this._keys.$index(i), this._values.$index(i));
+    if ((this._keys[i] != null) && (this._keys[i] != const$0001)) {
+      f.call$2(this._keys[i], this._values[i]);
     }
   }
 }
 HashMapImplementation.prototype.getKeys = function() {
   var list = new Array(this.get$length());
   var i = (0);
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
@@ skipping 11 matching lines @@
 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;
-HashMapImplementation.prototype.putIfAbsent$2 = function($0, $1) {
-  return this.putIfAbsent($0, to$call$0($1));
-};
 // ********** Code for HashMapImplementation_E$E **************
 $inherits(HashMapImplementation_E$E, HashMapImplementation);
 function HashMapImplementation_E$E() {
   this._numberOfEntries = (0);
   this._numberOfDeleted = (0);
   this._loadLimit = HashMapImplementation._computeLoadLimit((8));
   this._keys = new Array((8));
   this._values = new Array((8));
 }
 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));
+  return ($add(currentProbe, numberOfProbes)) & (length - (1));
 }
 HashMapImplementation_E$E.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   var insertionIndex = (-1);
   while (true) {
-    var existingKey = this._keys.$index(hash);
+    var existingKey = this._keys[hash];
     if (existingKey == null) {
       if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < (0)) && (const$0001 == existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_E$E.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
-    var existingKey = this._keys.$index(hash);
+    var existingKey = this._keys[hash];
     if (existingKey == null) return (-1);
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_E$E.prototype._ensureCapacity = function() {
-  var newNumberOfEntries = this._numberOfEntries + (1);
+  var newNumberOfEntries = $add(this._numberOfEntries, (1));
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.get$length() * (2));
     return;
   }
   var capacity = this._keys.get$length();
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if (this._numberOfDeleted > numberOfFree) {
     this._grow(this._keys.get$length());
   }
 }
 HashMapImplementation_E$E._isPowerOfTwo = function(x) {
   return ((x & (x - (1))) == (0));
 }
 HashMapImplementation_E$E.prototype._grow = function(newCapacity) {
   var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new Array(newCapacity);
   this._values = new Array(newCapacity);
   for (var i = (0);
    i < capacity; i++) {
-    var key = oldKeys.$index(i);
+    var key = oldKeys[i];
     if (key == null || key == const$0001) {
       continue;
     }
-    var value = oldValues.$index(i);
+    var value = oldValues[i];
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = (0);
 }
 HashMapImplementation_E$E.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$0001)) {
+  if ((this._keys[index] == null) || (this._keys[index] == const$0001)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
-HashMapImplementation_E$E.prototype.remove = function(key) {
-  var index = this._probeForLookup(key);
-  if (index >= (0)) {
-    this._numberOfEntries--;
-    var value = this._values.$index(index);
-    this._values.$setindex(index);
-    this._keys.$setindex(index, const$0001);
-    this._numberOfDeleted++;
-    return value;
-  }
-  return null;
-}
 HashMapImplementation_E$E.prototype.isEmpty = function() {
   return this._numberOfEntries == (0);
 }
 HashMapImplementation_E$E.prototype.forEach = function(f) {
   var length = this._keys.get$length();
   for (var i = (0);
    i < length; i++) {
-    if ((this._keys.$index(i) != null) && (this._keys.$index(i) != const$0001)) {
-      f(this._keys.$index(i), this._values.$index(i));
+    if ((this._keys[i] != null) && (this._keys[i] != const$0001)) {
+      f.call$2(this._keys[i], this._values[i]);
     }
   }
 }
 HashMapImplementation_E$E.prototype.getKeys = function() {
   var list = new Array(this.get$length());
   var i = (0);
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
@@ skipping 14 matching lines @@
   this._keys = new Array((8));
   this._values = new Array((8));
 }
 HashMapImplementation_K$V._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * (3)), (4));
 }
 HashMapImplementation_K$V._firstProbe = function(hashCode, length) {
   return hashCode & (length - (1));
 }
 HashMapImplementation_K$V._nextProbe = function(currentProbe, numberOfProbes, length) {
-  return (currentProbe + numberOfProbes) & (length - (1));
+  return ($add(currentProbe, numberOfProbes)) & (length - (1));
 }
 HashMapImplementation_K$V.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   var insertionIndex = (-1);
   while (true) {
-    var existingKey = this._keys.$index(hash);
+    var existingKey = this._keys[hash];
     if (existingKey == null) {
       if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < (0)) && (const$0001 == existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_K$V.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
-    var existingKey = this._keys.$index(hash);
+    var existingKey = this._keys[hash];
     if (existingKey == null) return (-1);
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_K$V.prototype._ensureCapacity = function() {
-  var newNumberOfEntries = this._numberOfEntries + (1);
+  var newNumberOfEntries = $add(this._numberOfEntries, (1));
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.get$length() * (2));
     return;
   }
   var capacity = this._keys.get$length();
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if (this._numberOfDeleted > numberOfFree) {
     this._grow(this._keys.get$length());
   }
 }
 HashMapImplementation_K$V._isPowerOfTwo = function(x) {
   return ((x & (x - (1))) == (0));
 }
 HashMapImplementation_K$V.prototype._grow = function(newCapacity) {
   var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new Array(newCapacity);
   this._values = new Array(newCapacity);
   for (var i = (0);
    i < capacity; i++) {
-    var key = oldKeys.$index(i);
+    var key = oldKeys[i];
     if (key == null || key == const$0001) {
       continue;
     }
-    var value = oldValues.$index(i);
+    var value = oldValues[i];
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = (0);
 }
 HashMapImplementation_K$V.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$0001)) {
+  if ((this._keys[index] == null) || (this._keys[index] == const$0001)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation_K$V.prototype.$index = function(key) {
   var index = this._probeForLookup(key);
   if (index < (0)) return null;
-  return this._values.$index(index);
+  return this._values[index];
 }
 HashMapImplementation_K$V.prototype.putIfAbsent = function(key, ifAbsent) {
   var index = this._probeForLookup(key);
-  if (index >= (0)) return this._values.$index(index);
-  var value = ifAbsent();
+  if (index >= (0)) return this._values[index];
+  var value = ifAbsent.call$0();
   this.$setindex(key, value);
   return value;
 }
 HashMapImplementation_K$V.prototype.isEmpty = function() {
   return this._numberOfEntries == (0);
 }
 HashMapImplementation_K$V.prototype.forEach = function(f) {
   var length = this._keys.get$length();
   for (var i = (0);
    i < length; i++) {
-    if ((this._keys.$index(i) != null) && (this._keys.$index(i) != const$0001)) {
-      f(this._keys.$index(i), this._values.$index(i));
+    if ((this._keys[i] != null) && (this._keys[i] != const$0001)) {
+      f.call$2(this._keys[i], this._values[i]);
     }
   }
 }
 HashMapImplementation_K$V.prototype.getKeys = function() {
   var list = new Array(this.get$length());
   var i = (0);
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
@@ skipping 20 matching lines @@
   this._keys = new Array((8));
   this._values = new Array((8));
 }
 HashMapImplementation_dart_core_String$VariableValue._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * (3)), (4));
 }
 HashMapImplementation_dart_core_String$VariableValue._firstProbe = function(hashCode, length) {
   return hashCode & (length - (1));
 }
 HashMapImplementation_dart_core_String$VariableValue._nextProbe = function(currentProbe, numberOfProbes, length) {
-  return (currentProbe + numberOfProbes) & (length - (1));
+  return ($add(currentProbe, numberOfProbes)) & (length - (1));
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   var insertionIndex = (-1);
   while (true) {
-    var existingKey = this._keys.$index(hash);
+    var existingKey = this._keys[hash];
     if (existingKey == null) {
       if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < (0)) && (const$0001 == existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
-    var existingKey = this._keys.$index(hash);
+    var existingKey = this._keys[hash];
     if (existingKey == null) return (-1);
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype._ensureCapacity = function() {
-  var newNumberOfEntries = this._numberOfEntries + (1);
+  var newNumberOfEntries = $add(this._numberOfEntries, (1));
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.get$length() * (2));
     return;
   }
   var capacity = this._keys.get$length();
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if (this._numberOfDeleted > numberOfFree) {
     this._grow(this._keys.get$length());
   }
 }
 HashMapImplementation_dart_core_String$VariableValue._isPowerOfTwo = function(x) {
   return ((x & (x - (1))) == (0));
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype._grow = function(newCapacity) {
   var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new Array(newCapacity);
   this._values = new Array(newCapacity);
   for (var i = (0);
    i < capacity; i++) {
-    var key = oldKeys.$index(i);
+    var key = oldKeys[i];
     if (key == null || key == const$0001) {
       continue;
     }
-    var value = oldValues.$index(i);
+    var value = oldValues[i];
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = (0);
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$0001)) {
+  if ((this._keys[index] == null) || (this._keys[index] == const$0001)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype.$index = function(key) {
   var index = this._probeForLookup(key);
   if (index < (0)) return null;
-  return this._values.$index(index);
+  return this._values[index];
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype.forEach = function(f) {
   var length = this._keys.get$length();
   for (var i = (0);
    i < length; i++) {
-    if ((this._keys.$index(i) != null) && (this._keys.$index(i) != const$0001)) {
-      f(this._keys.$index(i), this._values.$index(i));
+    if ((this._keys[i] != null) && (this._keys[i] != const$0001)) {
+      f.call$2(this._keys[i], this._values[i]);
     }
   }
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype.containsKey = function(key) {
   return (this._probeForLookup(key) != (-1));
 }
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
   this._backingMap = new HashMapImplementation_E$E();
 }
 HashSetImplementation.HashSetImplementation$from$factory = function(other) {
   var set = new HashSetImplementation_E();
   for (var $$i = other.iterator$0(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
     set.add(e);
   }
   return set;
 }
 HashSetImplementation.prototype.add = function(value) {
   this._backingMap.$setindex(value, value);
 }
 HashSetImplementation.prototype.contains = function(value) {
   return this._backingMap.containsKey(value);
 }
-HashSetImplementation.prototype.remove = function(value) {
-  if (!this._backingMap.containsKey(value)) return false;
-  this._backingMap.remove(value);
-  return true;
-}
 HashSetImplementation.prototype.addAll = function(collection) {
   var $this = this; // closure support
   collection.forEach(function _(value) {
     $this.add(value);
   }
   );
 }
 HashSetImplementation.prototype.forEach = function(f) {
   this._backingMap.forEach(function _(key, value) {
-    f(key);
+    f.call$1(key);
   }
   );
 }
 HashSetImplementation.prototype.filter = function(f) {
   var result = new HashSetImplementation();
   this._backingMap.forEach(function _(key, value) {
-    if (f(key)) result.add(key);
+    if (f.call$1(key)) result.add(key);
   }
   );
   return result;
 }
 HashSetImplementation.prototype.every = function(f) {
   var keys = this._backingMap.getKeys();
   return keys.every(f);
 }
 HashSetImplementation.prototype.some = function(f) {
   var keys = this._backingMap.getKeys();
   return keys.some(f);
 }
 HashSetImplementation.prototype.isEmpty = function() {
   return this._backingMap.isEmpty();
 }
 HashSetImplementation.prototype.get$length = function() {
   return this._backingMap.get$length();
 }
 HashSetImplementation.prototype.iterator = function() {
   return new HashSetIterator_E(this);
 }
 HashSetImplementation.prototype.add$1 = HashSetImplementation.prototype.add;
 HashSetImplementation.prototype.addAll$1 = HashSetImplementation.prototype.addAll;
 HashSetImplementation.prototype.contains$1 = HashSetImplementation.prototype.contains;
-HashSetImplementation.prototype.every$1 = function($0) {
-  return this.every(to$call$1($0));
-};
 HashSetImplementation.prototype.filter$1 = function($0) {
   return this.filter(to$call$1($0));
 };
 HashSetImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 HashSetImplementation.prototype.isEmpty$0 = HashSetImplementation.prototype.isEmpty;
 HashSetImplementation.prototype.iterator$0 = HashSetImplementation.prototype.iterator;
-HashSetImplementation.prototype.some$1 = function($0) {
-  return this.some(to$call$1($0));
-};
 // ********** Code for HashSetImplementation_E **************
 $inherits(HashSetImplementation_E, HashSetImplementation);
 function HashSetImplementation_E() {
   this._backingMap = new HashMapImplementation_E$E();
 }
 // ********** Code for HashSetImplementation_Library **************
 $inherits(HashSetImplementation_Library, HashSetImplementation);
 function HashSetImplementation_Library() {}
+// ********** Code for HashSetImplementation_Member **************
+$inherits(HashSetImplementation_Member, HashSetImplementation);
+function HashSetImplementation_Member() {}
 // ********** Code for HashSetImplementation_dart_core_String **************
 $inherits(HashSetImplementation_dart_core_String, HashSetImplementation);
 function HashSetImplementation_dart_core_String() {}
 // ********** Code for HashSetImplementation_Type **************
 $inherits(HashSetImplementation_Type, HashSetImplementation);
 function HashSetImplementation_Type() {}
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
   this._entries = set_._backingMap._keys;
   this._nextValidIndex = (-1);
   this._advance();
 }
 HashSetIterator.prototype.hasNext = function() {
   if (this._nextValidIndex >= this._entries.get$length()) return false;
-  if (this._entries.$index(this._nextValidIndex) == const$0001) {
+  if (this._entries[this._nextValidIndex] == const$0001) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.get$length();
 }
 HashSetIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$0005);
   }
-  var res = this._entries.$index(this._nextValidIndex);
+  var res = this._entries[this._nextValidIndex];
   this._advance();
   return res;
 }
 HashSetIterator.prototype._advance = function() {
   var length = this._entries.get$length();
   var entry;
   var deletedKey = const$0001;
   do {
     if (++this._nextValidIndex >= length) break;
-    entry = this._entries.$index(this._nextValidIndex);
+    entry = this._entries[this._nextValidIndex];
   }
   while ((entry == null) || (entry == deletedKey))
 }
 HashSetIterator.prototype.hasNext$0 = HashSetIterator.prototype.hasNext;
 HashSetIterator.prototype.next$0 = HashSetIterator.prototype.next;
 // ********** Code for HashSetIterator_E **************
 $inherits(HashSetIterator_E, HashSetIterator);
 function HashSetIterator_E(set_) {
   this._nextValidIndex = (-1);
   this._entries = set_._backingMap._keys;
   this._advance();
 }
 HashSetIterator_E.prototype._advance = function() {
   var length = this._entries.get$length();
   var entry;
   var deletedKey = const$0001;
   do {
     if (++this._nextValidIndex >= length) break;
-    entry = this._entries.$index(this._nextValidIndex);
+    entry = this._entries[this._nextValidIndex];
   }
   while ((entry == null) || (entry == deletedKey))
 }
 // ********** Code for _DeletedKeySentinel **************
 function _DeletedKeySentinel() {
 
 }
 // ********** Code for KeyValuePair **************
 function KeyValuePair(key, value) {
   this.value = value;
@@ skipping 22 matching lines @@
   }
 }
 LinkedHashMapImplementation.prototype.$index = function(key) {
   var entry = this._map.$index(key);
   if (entry == null) return null;
   return entry.get$element().get$value();
 }
 LinkedHashMapImplementation.prototype.putIfAbsent = function(key, ifAbsent) {
   var value = this.$index(key);
   if ((this.$index(key) == null) && !(this.containsKey(key))) {
-    value = ifAbsent();
+    value = ifAbsent.call$0();
     this.$setindex(key, value);
   }
   return value;
 }
 LinkedHashMapImplementation.prototype.getKeys = function() {
   var list = new Array(this.get$length());
   var index = (0);
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.key);
   }
   );
   return list;
 }
 LinkedHashMapImplementation.prototype.getValues = function() {
   var list = new Array(this.get$length());
   var index = (0);
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.value);
   }
   );
   return list;
 }
 LinkedHashMapImplementation.prototype.forEach = function(f) {
   this._list.forEach(function _(entry) {
-    f(entry.key, entry.value);
+    f.call$2(entry.key, entry.value);
   }
   );
 }
 LinkedHashMapImplementation.prototype.containsKey = function(key) {
   return this._map.containsKey(key);
 }
 LinkedHashMapImplementation.prototype.get$length = function() {
   return this._map.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;
-LinkedHashMapImplementation.prototype.putIfAbsent$2 = function($0, $1) {
-  return this.putIfAbsent($0, to$call$0($1));
-};
 // ********** Code for DoubleLinkedQueueEntry **************
 function DoubleLinkedQueueEntry(e) {
   this._element = e;
 }
 DoubleLinkedQueueEntry.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
 }
@@ skipping 136 matching lines @@
   );
   return counter;
 }
 DoubleLinkedQueue.prototype.isEmpty = function() {
   return (this._sentinel._next == this._sentinel);
 }
 DoubleLinkedQueue.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
-    f(entry._element);
+    f.call$1(entry._element);
     entry = nextEntry;
   }
 }
 DoubleLinkedQueue.prototype.every = function(f) {
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
-    if (!f(entry._element)) return false;
+    if (!f.call$1(entry._element)) return false;
     entry = nextEntry;
   }
   return true;
 }
 DoubleLinkedQueue.prototype.some = function(f) {
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
-    if (f(entry._element)) return true;
+    if (f.call$1(entry._element)) return true;
     entry = nextEntry;
   }
   return false;
 }
 DoubleLinkedQueue.prototype.filter = function(f) {
   var other = new DoubleLinkedQueue();
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
-    if (f(entry._element)) other.addLast(entry._element);
+    if (f.call$1(entry._element)) other.addLast(entry._element);
     entry = nextEntry;
   }
   return other;
 }
 DoubleLinkedQueue.prototype.iterator = function() {
   return new _DoubleLinkedQueueIterator_E(this._sentinel);
 }
 DoubleLinkedQueue.prototype.add$1 = DoubleLinkedQueue.prototype.add;
 DoubleLinkedQueue.prototype.addAll$1 = DoubleLinkedQueue.prototype.addAll;
 DoubleLinkedQueue.prototype.addLast$1 = DoubleLinkedQueue.prototype.addLast;
-DoubleLinkedQueue.prototype.every$1 = function($0) {
-  return this.every(to$call$1($0));
-};
 DoubleLinkedQueue.prototype.filter$1 = function($0) {
   return this.filter(to$call$1($0));
 };
 DoubleLinkedQueue.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 DoubleLinkedQueue.prototype.isEmpty$0 = DoubleLinkedQueue.prototype.isEmpty;
 DoubleLinkedQueue.prototype.iterator$0 = DoubleLinkedQueue.prototype.iterator;
 DoubleLinkedQueue.prototype.last$0 = DoubleLinkedQueue.prototype.last;
-DoubleLinkedQueue.prototype.removeFirst$0 = DoubleLinkedQueue.prototype.removeFirst;
 DoubleLinkedQueue.prototype.removeLast$0 = DoubleLinkedQueue.prototype.removeLast;
-DoubleLinkedQueue.prototype.some$1 = function($0) {
-  return this.some(to$call$1($0));
-};
 // ********** Code for DoubleLinkedQueue_E **************
 $inherits(DoubleLinkedQueue_E, DoubleLinkedQueue);
 function DoubleLinkedQueue_E() {}
 // ********** Code for DoubleLinkedQueue_KeyValuePair_K$V **************
 $inherits(DoubleLinkedQueue_KeyValuePair_K$V, DoubleLinkedQueue);
 function DoubleLinkedQueue_KeyValuePair_K$V() {
   this._sentinel = new _DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V();
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.addLast = function(value) {
   this._sentinel.prepend(value);
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.lastEntry = function() {
   return this._sentinel.previousEntry();
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
-    f(entry._element);
+    f.call$1(entry._element);
     entry = nextEntry;
   }
 }
 // ********** Code for _DoubleLinkedQueueIterator **************
 function _DoubleLinkedQueueIterator(_sentinel) {
   this._sentinel = _sentinel;
   this._currentEntry = this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.hasNext = function() {
   return this._currentEntry._next != this._sentinel;
@@ skipping 61 matching lines @@
 StringBufferImpl.prototype.get$length = function() {
   return this._length;
 }
 StringBufferImpl.prototype.isEmpty = function() {
   return this._length == (0);
 }
 StringBufferImpl.prototype.add = function(obj) {
   var str = obj.toString$0();
   if (str == null || str.isEmpty()) return this;
   this._buffer.add(str);
-  this._length += str.length;
+  this._length = $add(this._length, str.length);
   return this;
 }
 StringBufferImpl.prototype.addAll = function(objects) {
   for (var $$i = objects.iterator$0(); $$i.hasNext$0(); ) {
     var obj = $$i.next$0();
     this.add(obj);
   }
   return this;
 }
 StringBufferImpl.prototype.clear = function() {
   this._buffer = new Array();
   this._length = (0);
   return this;
 }
 StringBufferImpl.prototype.toString = function() {
   if (this._buffer.get$length() == (0)) return "";
-  if (this._buffer.get$length() == (1)) return this._buffer.$index((0));
+  if (this._buffer.get$length() == (1)) return this._buffer[(0)];
   var result = StringBase.concatAll(this._buffer);
   this._buffer.clear();
   this._buffer.add(result);
   return result;
 }
 StringBufferImpl.prototype.add$1 = StringBufferImpl.prototype.add;
 StringBufferImpl.prototype.addAll$1 = StringBufferImpl.prototype.addAll;
 StringBufferImpl.prototype.isEmpty$0 = StringBufferImpl.prototype.isEmpty;
 StringBufferImpl.prototype.toString$0 = StringBufferImpl.prototype.toString;
 // ********** Code for StringBase **************
 function StringBase() {}
 StringBase.createFromCharCodes = function(charCodes) {
   if (Object.getPrototypeOf(charCodes) !== Array.prototype) {
     charCodes = new ListFactory.ListFactory$from$factory(charCodes);
   }
   return String.fromCharCode.apply(null, charCodes);
 }
 StringBase.join = function(strings, separator) {
   if (strings.get$length() == (0)) return "";
-  var s = strings.$index((0));
+  var s = strings[(0)];
   for (var i = (1);
    i < strings.get$length(); i++) {
-    s = s + separator + strings.$index(i);
+    s = s + separator + strings[i];
   }
   return s;
 }
 StringBase.concatAll = function(strings) {
   return StringBase.join(strings, "");
 }
 // ********** Code for StringImplementation **************
 StringImplementation = String;
 StringImplementation.prototype.get$length = function() { return this.length; };
 StringImplementation.prototype.endsWith = function(other) {
@@ skipping 71 matching lines @@
 StringImplementation.prototype.isEmpty$0 = StringImplementation.prototype.isEmpty;
 StringImplementation.prototype.replaceFirst$2 = StringImplementation.prototype.replaceFirst;
 StringImplementation.prototype.startsWith$1 = StringImplementation.prototype.startsWith;
 StringImplementation.prototype.substring$1 = StringImplementation.prototype.substring;
 StringImplementation.prototype.substring$2 = StringImplementation.prototype.substring;
 // ********** Code for Collections **************
 function Collections() {}
 Collections.forEach = function(iterable, f) {
   for (var $$i = iterable.iterator$0(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
-    f(e);
+    f.call$1(e);
   }
 }
 Collections.some = function(iterable, f) {
   for (var $$i = iterable.iterator$0(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
-    if (f(e)) return true;
+    if (f.call$1(e)) return true;
   }
   return false;
 }
 Collections.every = function(iterable, f) {
   for (var $$i = iterable.iterator$0(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
-    if (!f(e)) return false;
+    if (!f.call$1(e)) return false;
   }
   return true;
 }
 Collections.filter = function(source, destination, f) {
   for (var $$i = source.iterator$0(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
-    if (f(e)) destination.add(e);
+    if (f.call$1(e)) destination.add(e);
   }
   return destination;
 }
 // ********** Code for _Worker **************
 // ********** Code for _ArgumentMismatchException **************
 $inherits(_ArgumentMismatchException, ClosureArgumentMismatchException);
 function _ArgumentMismatchException(_message) {
   this._dart_coreimpl_message = _message;
   ClosureArgumentMismatchException.call(this);
 }
@@ skipping 65 matching lines @@
       // TODO(jmesserly): evaluate the performance of these stubs.
       var f = 'function(' + a.join(',') + '){return $f(' + p.join(',') + ');}';
       return new Function('$f', 'return ' + f + '').call(null, this);
     
 }
 // ********** Code for top level **************
 function _map(itemsAndKeys) {
   var ret = new LinkedHashMapImplementation();
   for (var i = (0);
    i < itemsAndKeys.get$length(); ) {
-    ret.$setindex(itemsAndKeys.$index(i++), itemsAndKeys.$index(i++));
+    ret.$setindex(itemsAndKeys[i++], itemsAndKeys[i++]);
   }
   return ret;
 }
 //  ********** Library node **************
 // ********** Code for Process **************
 function Process(_process) {
   this.SIGSYS = "SIGSYS";
   this.SIGALRM = "SIGALRM";
   this.SIGXCPU = "SIGXCPU";
   this.SIGTSTP = "SIGTSTP";
@@ skipping 140 matching lines @@
 }
 function get$process() {
   return new Process(get$_process());
 }
 //  ********** Library file_system **************
 // ********** Code for top level **************
 function joinPaths(path1, path2) {
   var pieces = path1.split("/");
   var $$list = path2.split("/");
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var piece = $$list.$index($$i);
+    var piece = $$list[$$i];
     if ($eq(piece, "..") && pieces.get$length() > (0) && $ne(pieces.last$0(), ".") && $ne(pieces.last$0(), "..")) {
       pieces.removeLast$0();
     }
     else if ($ne(piece, "")) {
       if (pieces.get$length() > (0) && $eq(pieces.last$0(), ".")) {
         pieces.removeLast$0();
       }
       pieces.add$1(piece);
     }
   }
   return Strings.join(pieces, "/");
 }
 function dirname(path) {
   var lastSlash = path.lastIndexOf("/", path.length);
   if (lastSlash == (-1)) {
     return ".";
   }
   else {
     return path.substring((0), lastSlash);
   }
 }
 function basename(path) {
   var lastSlash = path.lastIndexOf("/", path.length);
   if (lastSlash == (-1)) {
     return path;
   }
   else {
-    return path.substring(lastSlash + (1));
+    return path.substring($add(lastSlash, (1)));
   }
 }
 //  ********** Library file_system_node **************
 // ********** Code for NodeFileSystem **************
 function NodeFileSystem() {
 
 }
 NodeFileSystem.prototype.writeString = function(outfile, text) {
   fs.writeFileSync(outfile, text);
 }
@@ skipping 325 matching lines @@
   else {
     if (this.useWrap0) {
       w.writeln("function $wrap_call$0(fn) { return fn; }");
     }
     if (this.useWrap1) {
       w.writeln("function $wrap_call$1(fn) { return fn; }");
     }
   }
   var $$list = orderValuesByKeys(this._usedOperators);
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var opImpl = $$list.$index($$i);
+    var opImpl = $$list[$$i];
     w.writeln(opImpl);
   }
   if ($globals.world.dom != null) {
     this.ensureTypeNameOf();
     w.writeln("Object.defineProperty(Object.prototype, \"get$typeName\", { value: Object.prototype.$typeNameOf, enumerable: false, writable: true, configurable: true});");
   }
 }
 CoreJs.prototype.generate$1 = CoreJs.prototype.generate;
 // ********** Code for Element **************
 function Element(name, _enclosingElement) {
@@ skipping 32 matching lines @@
 Element.prototype.resolve = function() {
 
 }
 Element.prototype.get$typeParameters = function() {
   return null;
 }
 Element.prototype.get$enclosingElement = function() {
   return this._enclosingElement == null ? this.get$library() : this._enclosingElement;
 }
 Element.prototype.set$enclosingElement = function(e) {
-  return this._enclosingElement = e;
+  var $0;
+  return (this._enclosingElement = ($0 = e), $0);
 }
 Element.prototype.resolveType = function(node, typeErrors) {
   if (node == null) return $globals.world.varType;
   if (node.type != null) return node.type;
   if ((node instanceof NameTypeReference)) {
     var typeRef = node;
     var name;
     if (typeRef.names != null) {
-      name = typeRef.names.last$0().get$name();
+      name = typeRef.names.last().get$name();
     }
     else {
       name = typeRef.name.name;
     }
     if (this.get$typeParameters() != null) {
       var $$list = this.get$typeParameters();
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-        var tp = $$list.$index($$i);
+        var tp = $$list[$$i];
         if ($eq(tp.get$name(), name)) {
           typeRef.type = tp;
         }
       }
     }
     if (typeRef.type != null) {
       return typeRef.type;
     }
     return this.get$enclosingElement().resolveType$2(node, typeErrors);
   }
   else if ((node instanceof GenericTypeReference)) {
     var typeRef = node;
     var baseType = this.resolveType$2(typeRef.baseType, typeErrors);
     if (!baseType.get$isGeneric()) {
       $globals.world.error(("" + baseType.get$name() + " is not generic"), typeRef.span);
       return null;
     }
     if (typeRef.typeArguments.get$length() != baseType.get$typeParameters().get$length()) {
       $globals.world.error("wrong number of type arguments", typeRef.span);
       return null;
     }
     var typeArgs = [];
     for (var i = (0);
      i < typeRef.typeArguments.get$length(); i++) {
-      typeArgs.add$1(this.resolveType$2(typeRef.typeArguments.$index(i), typeErrors));
+      typeArgs.add$1(this.resolveType$2(typeRef.typeArguments[i], typeErrors));
     }
     typeRef.type = baseType.getOrMakeConcreteType$1(typeArgs);
   }
   else if ((node instanceof FunctionTypeReference)) {
     var typeRef = node;
     var name = "";
     if (typeRef.func.name != null) {
       name = typeRef.func.name.name;
     }
     typeRef.type = this.get$library().getOrAddFunctionType(this, name, typeRef.func);
@@ skipping 23 matching lines @@
     this.markLibrariesUsed([$globals.world.coreimpl, $globals.world.corelib, this.main.declaringType.get$library()]);
   }
   $globals.world.numImplType.markUsed();
   $globals.world.stringImplType.markUsed();
   if ($globals.world.corelib.types.$index("Isolate").get$isUsed() || $globals.world.coreimpl.types.$index("ReceivePortImpl").get$isUsed()) {
     if (this.corejs.useWrap0 || this.corejs.useWrap1) {
       this.genMethod($globals.world.coreimpl.types.$index("IsolateContext").getMember$1("eval"));
       this.genMethod($globals.world.coreimpl.types.$index("EventLoop").getMember$1("run"));
     }
     this.corejs.useIsolates = true;
-    var isolateMain = $globals.world.coreimpl.topType.resolveMember("startRootIsolate").members.$index((0));
+    var isolateMain = $globals.world.coreimpl.lookup("startRootIsolate", this.main.get$span());
     var isolateMainTarget = new TypeValue($globals.world.coreimpl.topType, this.main.get$span());
     mainCall = isolateMain.invoke(metaGen, null, isolateMainTarget, new Arguments(null, [this.main._get(metaGen, this.main.definition, null, false)]), false);
   }
   this.writeTypes($globals.world.coreimpl);
   this.writeTypes($globals.world.corelib);
   this.writeTypes(this.main.declaringType.get$library());
   if (this._mixins != null) this.writer.write(this._mixins.get$text());
   this.writeDynamicDispatchMetadata();
   this.writeGlobals();
   this.writer.writeln(("" + mainCall.get$code() + ";"));
 }
 WorldGenerator.prototype.markLibrariesUsed = function(libs) {
   return this.getAllTypes(libs).forEach(this.get$markTypeUsed());
 }
 WorldGenerator.prototype.markTypeUsed = function(type) {
   if (!type.get$isClass()) return;
   type.markUsed();
   type.isTested = true;
-  type.isTested = !type.get$isTop() && !(type.get$isNative() && type.get$members().getValues$0().every$1((function (m) {
+  type.isTested = !type.get$isTop() && !(type.get$isNative() && type.get$members().getValues().every((function (m) {
     return m.get$isStatic() && !m.get$isFactory();
   })
   ));
-  var members = ListFactory.ListFactory$from$factory(type.get$members().getValues$0());
-  members.addAll$1(type.get$constructors().getValues$0());
+  var members = ListFactory.ListFactory$from$factory(type.get$members().getValues());
+  members.addAll$1(type.get$constructors().getValues());
   type.get$factories().forEach((function (f) {
     return members.add$1(f);
   })
   );
   for (var $$i = members.iterator$0(); $$i.hasNext$0(); ) {
     var member = $$i.next$0();
     if ((member instanceof PropertyMember)) {
       if (member.get$getter() != null) this.genMethod(member.get$getter());
       if (member.get$setter() != null) this.genMethod(member.get$setter());
     }
     if ((member instanceof MethodMember)) this.genMethod(member);
   }
 }
 WorldGenerator.prototype.get$markTypeUsed = function() {
   return this.markTypeUsed.bind(this);
 }
 WorldGenerator.prototype.getAllTypes = function(libs) {
   var types = [];
   var seen = new HashSetImplementation();
   for (var $$i = 0;$$i < libs.get$length(); $$i++) {
-    var mainLib = libs.$index($$i);
+    var mainLib = libs[$$i];
     var toCheck = DoubleLinkedQueue.DoubleLinkedQueue$from$factory([mainLib]);
     while (!toCheck.isEmpty()) {
-      var lib = toCheck.removeFirst$0();
+      var lib = toCheck.removeFirst();
       if (seen.contains(lib)) continue;
       seen.add(lib);
       lib.get$imports().forEach$1((function (lib, toCheck, i) {
         return toCheck.addLast(lib);
       }).bind(null, lib, toCheck)
       );
       lib.get$types().getValues$0().forEach$1((function (t) {
         return types.add(t);
       })
       );
     }
   }
   return types;
 }
 WorldGenerator.prototype.globalForStaticField = function(field, exp, dependencies) {
   this.hasStatics = true;
   var key = ("" + field.declaringType.get$jsname() + "." + field.get$jsname());
   var ret = this.globals.$index(key);
   if (ret == null) {
     ret = new GlobalValue(exp.get$type(), exp.get$code(), field.isFinal, field, null, exp, exp.span, dependencies);
     this.globals.$setindex(key, ret);
   }
   return ret;
 }
 WorldGenerator.prototype.globalForConst = function(exp, dependencies) {
   var key = exp.get$type().get$jsname() + ":" + exp.get$code();
   var ret = this.globals.$index(key);
   if (ret == null) {
-    var ns = this.globals.get$length().toString();
+    var ns = this.globals.get$length().toString$0();
     while (ns.get$length() < (4)) ns = "0" + ns;
     var name = ("const$" + ns);
     ret = new GlobalValue(exp.get$type(), name, true, null, name, exp, exp.span, dependencies);
     this.globals.$setindex(key, ret);
   }
   return ret;
 }
 WorldGenerator.prototype.writeTypes = function(lib) {
   if (lib.isWritten) return;
   lib.isWritten = true;
   var $$list = lib.imports;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var import_ = $$list.$index($$i);
+    var import_ = $$list[$$i];
     this.writeTypes(import_.get$library());
   }
   for (var i = (0);
    i < lib.sources.get$length(); i++) {
-    lib.sources.$index(i).set$orderInLibrary(i);
+    lib.sources[i].set$orderInLibrary(i);
   }
   this.writer.comment(("//  ********** Library " + lib.name + " **************"));
   if (lib.get$isCore()) {
     this.writer.comment("//  ********** Natives dart:core **************");
     this.corejs.generate(this.writer);
   }
   var $$list = lib.natives;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var file = $$list.$index($$i);
+    var file = $$list[$$i];
     var filename = basename(file.get$filename());
     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.get$length(); $$i++) {
-    var type = $$list.$index($$i);
-    if ((type.get$isUsed() || type.get$library().get$isDom() || type.get$isHiddenNativeType()) && type.get$isClass()) {
+  var orderedTypes = this._orderValues(lib.types);
+  for (var $$i = orderedTypes.iterator$0(); $$i.hasNext$0(); ) {
+    var type = $$i.next$0();
+    if ((type.get$library().get$isDom() || type.get$isHiddenNativeType()) && type.get$isClass()) {
+      type.markUsed$0();
+    }
+  }
+  for (var $$i = orderedTypes.iterator$0(); $$i.hasNext$0(); ) {
+    var type = $$i.next$0();
+    if (type.get$isUsed() && type.get$isClass()) {
       this.writeType(type);
       if (type.get$isGeneric()) {
-        var $list0 = this._orderValues(type.get$_concreteTypes());
-        for (var $i0 = 0;$i0 < $list0.get$length(); $i0++) {
-          var ct = $list0.$index($i0);
+        var $$list = this._orderValues(type.get$_concreteTypes());
+        for (var $i0 = 0;$i0 < $$list.get$length(); $i0++) {
+          var ct = $$list[$i0];
           this.writeType(ct);
         }
       }
     }
     else if (type.get$isFunction() && type.get$varStubs().get$length() > (0)) {
       this.writer.comment(("// ********** Code for " + type.get$jsname() + " **************"));
       this._writeDynamicStubs(type);
     }
     if (type.get$typeCheckCode() != null) {
       this.writer.writeln(type.get$typeCheckCode());
@@ skipping 114 matching lines @@
   else {
     var standardConstructor = type.get$constructors().$index("");
     if (standardConstructor == null || standardConstructor.generator == null) {
       if (!type.get$isNative()) {
         this.writer.writeln(("function " + type.get$jsname() + "() {}"));
       }
     }
     else {
       standardConstructor.generator.writeDefinition(this.writer, null);
     }
-    var $$list = type.get$constructors().getValues$0();
+    var $$list = type.get$constructors().getValues();
     for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
       var c = $$i.next$0();
       if (c.get$generator() != null && $ne(c, standardConstructor)) {
         c.get$generator().writeDefinition$2(this.writer);
       }
     }
   }
   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.get$length(); $$i++) {
-      var ct = $$list.$index($$i);
+      var ct = $$list[$$i];
       this._maybeIsTest(type, ct);
     }
   }
   if (type.get$interfaces() != null) {
     var seen = new HashSetImplementation();
     var worklist = [];
     worklist.addAll$1(type.get$interfaces());
     seen.addAll$1(type.get$interfaces());
     while (!worklist.isEmpty$0()) {
       var interface_ = worklist.removeLast$0();
       this._maybeIsTest(type, interface_.get$genericType());
       if (interface_.get$genericType().get$_concreteTypes() != null) {
         var $$list = this._orderValues(interface_.get$genericType().get$_concreteTypes());
         for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-          var ct = $$list.$index($$i);
+          var ct = $$list[$$i];
           this._maybeIsTest(type, ct);
         }
       }
       var $$list = interface_.get$interfaces();
       for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
         var other = $$i.next$0();
         if (!seen.contains$1(other)) {
           worklist.addLast$1(other);
           seen.add$1(other);
         }
       }
     }
   }
   type.get$factories().forEach(this.get$_writeMethod());
   var $$list = this._orderValues(type.get$members());
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var member = $$list.$index($$i);
+    var member = $$list[$$i];
     if ((member instanceof FieldMember)) {
       this._writeField(member);
     }
     if ((member instanceof PropertyMember)) {
       this._writeProperty(member);
     }
     if (member.get$isMethod()) {
       this._writeMethod(member);
     }
   }
   this._writeDynamicStubs(type);
 }
 WorldGenerator.prototype._typeNeedsHolderForStaticMethods = function(type) {
-  var $$list = type.get$members().getValues$0();
+  var $$list = type.get$members().getValues();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var member = $$i.next$0();
     if (member.get$isMethod()) {
       if (member.get$isConstructor() || member.get$isStatic()) {
         if (member.get$isGenerated()) {
           return true;
         }
       }
     }
   }
   return false;
 }
 WorldGenerator.prototype._ensureInheritMembersHelper = function() {
   if (this._mixins != null) return;
   this._mixins = new CodeWriter();
   this._mixins.comment("// ********** Generic Type Inheritance **************");
   this._mixins.writeln("/** Implements extends for generic types. */\nfunction $inheritsMembers(child, parent) {\n  child = child.prototype;\n  parent = parent.prototype;\n  Object.getOwnPropertyNames(parent).forEach(function(name) {\n    if (typeof(child[name]) == 'undefined') child[name] = parent[name];\n  });\n}");
 }
 WorldGenerator.prototype._writeDynamicStubs = function(type) {
   var $$list = orderValuesByKeys(type.varStubs);
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var stub = $$list.$index($$i);
+    var stub = $$list[$$i];
     if (!stub.get$isGenerated()) stub.generate$1(this.writer);
   }
 }
 WorldGenerator.prototype._writeStaticField = function(field) {
   if (field.isFinal) return;
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname());
   if (this.globals.containsKey(fullname)) {
     var value = this.globals.$index(fullname);
     if (field.declaringType.get$isTop() && !field.isNative) {
       this.writer.writeln(("$globals." + field.get$jsname() + " = " + value.get$exp().get$code() + ";"));
@@ skipping 36 matching lines @@
   else if ((m instanceof MethodMember) && m.get$isNative() && m._providePropertySyntax && !m._provideFieldSyntax) {
     MethodGenerator._maybeGenerateBoundGetter(m, this.writer);
   }
 }
 WorldGenerator.prototype.get$_writeMethod = function() {
   return this._writeMethod.bind(this);
 }
 WorldGenerator.prototype.writeGlobals = function() {
   if (this.globals.get$length() > (0)) {
     this.writer.comment("//  ********** Globals **************");
-    var list = this.globals.getValues$0();
+    var list = this.globals.getValues();
     list.sort$1((function (a, b) {
       return a.compareTo$1(b);
     })
     );
     this.writer.enterBlock("function $static_init(){");
     for (var $$i = list.iterator$0(); $$i.hasNext$0(); ) {
       var global = $$i.next$0();
       if (global.get$field() != null) {
         this._writeStaticField(global.get$field());
       }
@@ skipping 23 matching lines @@
   var $this = this; // closure support
   if (this.typesWithDynamicDispatch == null) return;
   this.writer.comment(("// " + this.typesWithDynamicDispatch.get$length() + " dynamic types."));
   var seen = new HashSetImplementation();
   var types = [];
   function visit(type) {
     if (seen.contains$1(type)) return;
     seen.add$1(type);
     var $$list = $this._orderCollectionValues(type.get$directSubtypes());
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var subtype = $$list.$index($$i);
-      visit(subtype);
+      var subtype = $$list[$$i];
+      visit.call$1(subtype);
     }
     types.add$1(type);
   }
   var $$list = this._orderCollectionValues(this.typesWithDynamicDispatch);
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var type = $$list.$index($$i);
-    visit(type);
+    var type = $$list[$$i];
+    visit.call$1(type);
   }
   var dispatchTypes = types.filter$1((function (type) {
     return !type.get$directSubtypes().isEmpty$0() && $this.typesWithDynamicDispatch.contains(type);
   })
   );
   this.writer.comment(("// " + types.get$length() + " types"));
   this.writer.comment(("// " + types.filter$1((function (t) {
     return !t.get$directSubtypes().isEmpty$0();
   })
   ).get$length() + " !leaf"));
   var varNames = [];
   var varDefns = new HashMapImplementation();
   var tagDefns = new HashMapImplementation();
   function makeExpression(type) {
     var expressions = [];
     var subtags = [type.get$nativeName()];
     function walk(type) {
       var $$list = $this._orderCollectionValues(type.get$directSubtypes());
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-        var subtype = $$list.$index($$i);
+        var subtype = $$list[$$i];
         var tag = subtype.get$nativeName();
         var existing = tagDefns.$index(tag);
         if (existing == null) {
           subtags.add$1(tag);
-          walk(subtype);
+          walk.call$1(subtype);
         }
         else {
           if (varDefns.containsKey$1(existing)) {
             expressions.add$1(existing);
           }
           else {
             var varName = ("v" + varNames.get$length() + "/*" + tag + "*/");
             varNames.add$1(varName);
             varDefns.$setindex(varName, existing);
             tagDefns.$setindex(tag, varName);
             expressions.add$1(varName);
           }
         }
       }
     }
-    walk(type);
+    walk.call$1(type);
     var constantPart = ("'" + Strings.join(subtags, "|") + "'");
     if ($ne(constantPart, "''")) expressions.add$1(constantPart);
     var expression;
     if ($eq(expressions.get$length(), (1))) {
       expression = expressions.$index((0));
     }
     else {
       expression = ("[" + Strings.join(expressions, ",") + "].join('|')");
     }
     return expression;
   }
   for (var $$i = dispatchTypes.iterator$0(); $$i.hasNext$0(); ) {
     var type = $$i.next$0();
-    tagDefns.$setindex(type.get$nativeName(), makeExpression(type));
+    tagDefns.$setindex(type.get$nativeName(), makeExpression.call$1(type));
   }
   if (!tagDefns.isEmpty$0()) {
     this.writer.enterBlock("(function(){");
     for (var $$i = varNames.iterator$0(); $$i.hasNext$0(); ) {
       var varName = $$i.next$0();
       this.writer.writeln(("var " + varName + " = " + varDefns.$index(varName) + ";"));
     }
     this.writer.enterBlock("var table = [");
     this.writer.comment("// [dynamic-dispatch-tag, tags of classes implementing dynamic-dispatch-tag]");
     for (var $$i = dispatchTypes.iterator$0(); $$i.hasNext$0(); ) {
@@ skipping 64 matching lines @@
 }
 MethodGenerator.prototype.get$isStatic = function() {
   return this.method.get$isStatic();
 }
 MethodGenerator.prototype.getTemp = function(value) {
   return value.get$needsTemp() ? this.forceTemp(value) : value;
 }
 MethodGenerator.prototype.forceTemp = function(value) {
   var name;
   if (this._freeTemps.get$length() > (0)) {
-    name = this._freeTemps.removeLast$0();
+    name = this._freeTemps.removeLast();
   }
   else {
     name = "$" + this._usedTemps.get$length();
   }
   this._usedTemps.add(name);
   return new VariableValue(value.get$staticType(), name, value.span, false, value);
 }
 MethodGenerator.prototype.assignTemp = function(tmp, v) {
   if ($eq(tmp, v)) {
     return v;
   }
   else {
     return new Value(v.get$type(), ("(" + tmp.get$code() + " = " + v.get$code() + ")"), v.span);
   }
 }
 MethodGenerator.prototype.freeTemp = function(value) {
-  if (this._usedTemps.remove(value.code)) {
-    this._freeTemps.add(value.code);
-  }
-  else {
-    $globals.world.internalError(("tried to free unused value or non-temp \"" + value.code + "\""));
-  }
+
 }
 MethodGenerator.prototype.run = function() {
   if (this.method.isGenerated) return;
   this.method.isGenerated = true;
   this.method.generator = this;
   var thisObject;
   if (this.method.get$isConstructor()) {
     thisObject = new ObjectValue(false, this.method.declaringType, this.method.get$span());
     thisObject.initFields$0();
   }
   else {
     thisObject = new Value(this.method.declaringType, "this", null);
   }
   var values = [];
   var $$list = this.method.get$parameters();
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var p = $$list.$index($$i);
+    var p = $$list[$$i];
     values.add$1(new Value(p.get$type(), p.get$name(), null));
   }
   var args = new Arguments(null, values);
   this.evalBody(thisObject, args);
   if (this.method.get$definition().get$nativeBody() != null) {
     this.writer = new CodeWriter();
     if ($eq(this.method.get$definition().get$nativeBody(), "")) {
       this.method.generator = null;
     }
     else {
@@ skipping 97 matching lines @@
 }
 MethodGenerator.prototype._provideOptionalParamInfo = function(defWriter) {
   if ((this.method instanceof MethodMember)) {
     var meth = this.method;
     if (meth._provideOptionalParamInfo) {
       var optNames = [];
       var optValues = [];
       meth.genParameterValues();
       var $$list = meth.parameters;
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-        var param = $$list.$index($$i);
+        var param = $$list[$$i];
         if (param.get$isOptional()) {
           optNames.add$1(param.get$name());
           optValues.add$1(MethodGenerator._escapeString(param.get$value().get$code()));
         }
       }
       if (optNames.get$length() > (0)) {
         var start = "";
         if (meth.isStatic) {
           if (!meth.declaringType.get$isTop()) {
             start = meth.declaringType.get$jsname() + ".";
@@ skipping 20 matching lines @@
   return newObject.setField(field, value, true);
 }
 MethodGenerator.prototype.evalBody = function(newObject, args) {
   var fieldsSet = false;
   if (this.method.get$isNative() && this.method.get$isConstructor() && (newObject instanceof ObjectValue)) {
     newObject.get$dynamic().set$seenNativeInitializer(true);
   }
   this._paramCode = [];
   for (var i = (0);
    i < this.method.get$parameters().get$length(); i++) {
-    var p = this.method.get$parameters().$index(i);
+    var p = this.method.get$parameters()[i];
     var currentArg = null;
     if (i < args.get$bareCount()) {
-      currentArg = args.values.$index(i);
+      currentArg = args.values[i];
     }
     else {
       currentArg = args.getValue(p.get$name());
       if (currentArg == null) {
         p.genValue$2(this.method, this.method.generator);
         currentArg = p.get$value();
       }
     }
     if (p.get$isInitializer()) {
       this._paramCode.add(p.get$name());
@@ skipping 122 matching lines @@
     var value = m.invoke$4(this, node, target, newArgs);
     if ($ne(target.get$type(), $globals.world.objectType)) {
       this.writer.writeln(("" + value.get$code() + ";"));
     }
   }
 }
 MethodGenerator.prototype._makeArgs = function(arguments) {
   var args = [];
   var seenLabel = false;
   for (var $$i = 0;$$i < arguments.get$length(); $$i++) {
-    var arg = arguments.$index($$i);
+    var arg = arguments[$$i];
     if (arg.get$label() != null) {
       seenLabel = true;
     }
     else if (seenLabel) {
       $globals.world.error("bare argument can not follow named arguments", arg.get$span());
     }
     args.add$1(this.visitValue(arg.get$value()));
   }
   return new Arguments(arguments, args);
 }
 MethodGenerator.prototype._invokeNative = function(name, arguments) {
   var args = Arguments.get$EMPTY();
   if (arguments.get$length() > (0)) {
     args = new Arguments(null, arguments);
   }
   var method = $globals.world.corelib.topType.members.$index(name);
   return method.invoke$4(this, method.get$definition(), new Value($globals.world.corelib.topType, null, null), args);
 }
 MethodGenerator._escapeString = function(text) {
   return text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("\r", "\\r");
 }
 MethodGenerator.prototype.visitStatementsInBlock = function(body) {
   if ((body instanceof BlockStatement)) {
     var block = body;
     var $$list = block.body;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var stmt = $$list.$index($$i);
+      var stmt = $$list[$$i];
       stmt.visit$1(this);
     }
   }
   else {
     if (body != null) body.visit(this);
   }
   return false;
 }
 MethodGenerator.prototype._pushBlock = function(node, reentrant) {
   this._scope = new BlockScope(this, this._scope, node, reentrant);
 }
 MethodGenerator.prototype._popBlock = function(node) {
   if (this._scope.node != node) {
     function spanOf(n) {
       return n != null ? n.get$span() : null;
     }
-    $globals.world.internalError(("scope mismatch. Trying to pop \"" + node + "\" but found ") + (" \"" + this._scope.node + "\""), spanOf(node), spanOf(this._scope.node));
+    $globals.world.internalError(("scope mismatch. Trying to pop \"" + node + "\" but found ") + (" \"" + this._scope.node + "\""), spanOf.call$1(node), spanOf.call$1(this._scope.node));
   }
   this._scope = this._scope.parent;
 }
 MethodGenerator.prototype._visitLoop = function(node, visitBody) {
   if (this._scope.inferTypes) {
     this._loopFixedPoint(node, visitBody);
   }
   else {
     this._pushBlock(node, true);
-    visitBody();
+    visitBody.call$0();
     this._popBlock(node);
   }
 }
 MethodGenerator.prototype._loopFixedPoint = function(node, visitBody) {
   var savedCounters = this.counters;
   var savedWriter = this.writer;
   var tries = (0);
   var startScope = this._scope.snapshot();
   var s = startScope;
   while (true) {
     this.writer = new CodeWriter();
     this.counters = new CounterLog();
     this._pushBlock(node, true);
     if (tries++ >= $globals.options.maxInferenceIterations) {
       this._scope.inferTypes = false;
     }
-    visitBody();
+    visitBody.call$0();
     this._popBlock(node);
     if (!this._scope.inferTypes || !this._scope.unionWith(s)) {
       break;
     }
     s = this._scope.snapshot();
   }
   savedWriter.write$1(this.writer.get$text());
   this.writer = savedWriter;
   savedCounters.add$1(this.counters);
   this.counters = savedCounters;
@@ skipping 31 matching lines @@
   }
   return this.visitValue(node);
 }
 MethodGenerator.prototype.visitDietStatement = function(node) {
   var parser = new Parser(node.span.file, false, false, false, node.span.start);
   this.visitStatementsInBlock(parser.block$0());
   return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var isFinal = false;
-  if (node.modifiers != null && $eq(node.modifiers.$index((0)).get$kind(), (99))) {
+  if (node.modifiers != null && $eq(node.modifiers[(0)].get$kind(), (99))) {
     isFinal = true;
   }
   this.writer.write("var ");
   var type = this.method.resolveType$2(node.type, false);
   for (var i = (0);
    i < node.names.get$length(); i++) {
     if (i > (0)) {
       this.writer.write(", ");
     }
-    var name = node.names.$index(i).get$name();
-    var value = this.visitValue(node.values.$index(i));
+    var name = node.names[i].get$name();
+    var value = this.visitValue(node.values[i]);
     if (isFinal && value == null) {
       $globals.world.error("no value specified for final variable", node.span);
     }
-    var val = this._scope.create(name, type, node.names.$index(i).get$span(), isFinal, false);
+    var val = this._scope.create(name, type, node.names[i].get$span(), isFinal, false);
     if (value == null) {
       if (this._scope.reentrant) {
         this.writer.write(("" + val.get$code() + " = null"));
       }
       else {
         this.writer.write(("" + val.get$code()));
       }
     }
     else {
       value = value.convertTo$2(this, type);
@@ skipping 121 matching lines @@
     if (node.test != null) {
       var test = $this.visitBool(node.test);
       $this.writer.write((" " + test.get$code() + "; "));
     }
     else {
       $this.writer.write("; ");
     }
     var needsComma = false;
     var $$list = node.step;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var s = $$list.$index($$i);
+      var s = $$list[$$i];
       if (needsComma) $this.writer.write(", ");
       var sv = $this.visitVoid(s);
       $this.writer.write(sv.get$code());
       needsComma = true;
     }
     $this.writer.write(") ");
     $this._pushBlock(node.body, false);
     node.body.visit($this);
     $this._popBlock(node.body);
   })
@@ skipping 51 matching lines @@
 MethodGenerator.prototype._genStackTraceOf = function(trace, ex) {
   var result = this._invokeNative("_stackTraceOf", [ex]);
   this.writer.writeln(("var " + trace.get$code() + " = " + result.get$code() + ";"));
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
   this.writer.enterBlock("try {");
   this._pushBlock(node.body, false);
   this.visitStatementsInBlock(node.body);
   this._popBlock(node.body);
   if (node.catches.get$length() == (1)) {
-    var catch_ = node.catches.$index((0));
+    var catch_ = node.catches[(0)];
     this._pushBlock(catch_, false);
     var exType = this.method.resolveType$2(catch_.get$exception().get$type(), false);
     var ex = this._scope.declare(catch_.get$exception());
     this._scope.rethrow = ex.get$code();
     this.writer.nextBlock(("} catch (" + ex.get$code() + ") {"));
     if (catch_.get$trace() != null) {
       var trace = this._scope.declare(catch_.get$trace());
       this._genStackTraceOf(trace, ex);
     }
     this._genToDartException(ex);
     if (!exType.get$isVarOrObject()) {
       var test = ex.instanceOf$3$isTrue$forceCheck(this, exType, catch_.get$exception().get$span(), false, true);
       this.writer.writeln(("if (" + test.get$code() + ") throw " + ex.get$code() + ";"));
     }
-    this.visitStatementsInBlock(node.catches.$index((0)).get$body());
+    this.visitStatementsInBlock(node.catches[(0)].get$body());
     this._popBlock(catch_);
   }
   else if (node.catches.get$length() > (0)) {
     this._pushBlock(node, false);
     var ex = this._scope.create("$ex", $globals.world.varType, null, false, false);
     this._scope.rethrow = ex.get$code();
     this.writer.nextBlock(("} catch (" + ex.get$code() + ") {"));
     var trace = null;
     if (node.catches.some((function (c) {
       return c.get$trace() != null;
     })
     )) {
       trace = this._scope.create("$trace", $globals.world.varType, null, false, false);
       this._genStackTraceOf(trace, ex);
     }
     this._genToDartException(ex);
     var needsRethrow = true;
     for (var i = (0);
      i < node.catches.get$length(); i++) {
-      var catch_ = node.catches.$index(i);
+      var catch_ = node.catches[i];
       this._pushBlock(catch_, false);
       var tmpType = this.method.resolveType$2(catch_.get$exception().get$type(), false);
       var tmp = this._scope.declare(catch_.get$exception());
       if (!tmpType.get$isVarOrObject()) {
         var test = ex.instanceOf$3$isTrue$forceCheck(this, tmpType, catch_.get$exception().get$span(), true, true);
         if (i == (0)) {
           this.writer.enterBlock(("if (" + test.get$code() + ") {"));
         }
         else {
           this.writer.nextBlock(("} else if (" + test.get$code() + ") {"));
         }
       }
       else if (i > (0)) {
         this.writer.nextBlock("} else {");
       }
       this.writer.writeln(("var " + tmp.get$code() + " = " + ex.get$code() + ";"));
       if (catch_.get$trace() != null) {
         var tmptrace = this._scope.declare(catch_.get$trace());
         this.writer.writeln(("var " + tmptrace.get$code() + " = " + trace.get$code() + ";"));
       }
       this.visitStatementsInBlock(catch_.get$body());
       this._popBlock(catch_);
       if (tmpType.get$isVarOrObject()) {
-        if (i + (1) < node.catches.get$length()) {
-          $globals.world.error("Unreachable catch clause", node.catches.$index(i + (1)).get$span());
+        if ($add(i, (1)) < node.catches.get$length()) {
+          $globals.world.error("Unreachable catch clause", node.catches[$add(i, (1))].get$span());
         }
         if (i > (0)) {
           this.writer.exitBlock("}");
         }
         needsRethrow = false;
         break;
       }
     }
     if (needsRethrow) {
       this.writer.nextBlock("} else {");
       this.writer.writeln(("throw " + ex.get$code() + ";"));
       this.writer.exitBlock("}");
     }
     this._popBlock(node);
   }
   if (node.finallyBlock != null) {
     this.writer.nextBlock("} finally {");
     this._pushBlock(node.finallyBlock, false);
     this.visitStatementsInBlock(node.finallyBlock);
     this._popBlock(node.finallyBlock);
   }
   this.writer.exitBlock("}");
   return false;
 }
 MethodGenerator.prototype.visitSwitchStatement = function(node) {
   var test = this.visitValue(node.test);
   this.writer.enterBlock(("switch (" + test.get$code() + ") {"));
   var $$list = node.cases;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var case_ = $$list.$index($$i);
+    var case_ = $$list[$$i];
     if (case_.get$label() != null) {
       $globals.world.error("unimplemented: labeled case statement", case_.get$span());
     }
     this._pushBlock(case_, false);
     for (var i = (0);
      i < case_.get$cases().get$length(); i++) {
       var expr = case_.get$cases().$index(i);
       if (expr == null) {
         if (i < case_.get$cases().get$length() - (1)) {
           $globals.world.error("default clause must be the last case", case_.get$span());
         }
         this.writer.writeln("default:");
       }
       else {
         var value = this.visitValue(expr);
         this.writer.writeln(("case " + value.get$code() + ":"));
       }
     }
     this.writer.enterBlock("");
     var caseExits = this._visitAllStatements(case_.get$statements(), false);
-    if ($ne(case_, node.cases.$index(node.cases.get$length() - (1))) && !caseExits) {
+    if ($ne(case_, node.cases[node.cases.get$length() - (1)]) && !caseExits) {
       var span = case_.get$statements().$index(case_.get$statements().get$length() - (1)).get$span();
       this.writer.writeln("$throw(new FallThroughError());");
       $globals.world.gen.corejs.useThrow = true;
     }
     this.writer.exitBlock("");
     this._popBlock(case_);
   }
   this.writer.exitBlock("}");
   return false;
 }
 MethodGenerator.prototype._visitAllStatements = function(statementList, exits) {
   for (var i = (0);
    i < statementList.get$length(); i++) {
     var stmt = statementList.$index(i);
     exits = stmt.visit$1(this);
     if ($ne(stmt, statementList.$index(statementList.get$length() - (1))) && exits) {
-      $globals.world.warning("unreachable code", statementList.$index(i + (1)).get$span());
+      $globals.world.warning("unreachable code", statementList.$index($add(i, (1))).get$span());
     }
   }
   return exits;
 }
 MethodGenerator.prototype.visitBlockStatement = function(node) {
   this._pushBlock(node, false);
   this.writer.enterBlock("{");
   var exits = this._visitAllStatements(node.body, false);
   this.writer.exitBlock("}");
   this._popBlock(node);
@@ skipping 115 matching lines @@
     var y = this.visitValue(node.y);
     return x.binop$4(kind, y, this, node);
   }
   var assignKind = TokenKind.kindFromAssign(node.op.kind);
   if ($eq(assignKind, (-1))) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     return x.binop$4(kind, y, this, node);
   }
   else if (($ne(assignKind, (0))) && this._expressionNeedsParens(node.y)) {
-    return this._visitAssign(assignKind, node.x, new ParenExpression(node.y, node.y.span), node, to$call$1(null), isVoid);
+    return this._visitAssign(assignKind, node.x, new ParenExpression(node.y, node.y.span), node, isVoid ? (1) : (2));
   }
   else {
-    return this._visitAssign(assignKind, node.x, node.y, node, to$call$1(null), isVoid);
+    return this._visitAssign(assignKind, node.x, node.y, node, isVoid ? (1) : (2));
   }
 }
-MethodGenerator.prototype._visitAssign = function(kind, xn, yn, position, captureOriginal, isVoid) {
-  if (captureOriginal == null) {
-    captureOriginal = (function (x) {
-      return x;
-    })
-    ;
-  }
+MethodGenerator.prototype._visitAssign = function(kind, xn, yn, position, returnKind) {
   if ((xn instanceof VarExpression)) {
-    return this._visitVarAssign(kind, xn, yn, position, captureOriginal);
+    return this._visitVarAssign(kind, xn, yn, position, returnKind);
   }
   else if ((xn instanceof IndexExpression)) {
-    return this._visitIndexAssign(kind, xn, yn, position, captureOriginal, isVoid);
+    return this._visitIndexAssign(kind, xn, yn, position, returnKind);
   }
   else if ((xn instanceof DotExpression)) {
-    return this._visitDotAssign(kind, xn, yn, position, captureOriginal);
+    return this._visitDotAssign(kind, xn, yn, position, returnKind);
   }
   else {
     $globals.world.error("illegal lhs", xn.span);
   }
 }
-MethodGenerator.prototype._visitVarAssign = function(kind, xn, yn, position, captureOriginal) {
+MethodGenerator.prototype._visitVarAssign = function(kind, xn, yn, position, returnKind) {
   var name = xn.name.name;
   var x = this._scope.lookup(name);
   var y = this.visitValue(yn);
   if (x != null) {
     y = y.convertTo$2(this, x.get$staticType());
     this._scope.inferAssign(name, Value.union(x, y));
+    if (x.get$isFinal()) {
+      $globals.world.error(("final variable \"" + x.get$code() + "\" is not assignable"), position.span);
+    }
+    if (kind == (0)) {
+      return new Value(y.get$type(), ("" + x.get$code() + " = " + y.get$code()), position.span);
+    }
+    else if (x.get$type().get$isNum() && y.get$type().get$isNum() && (kind != (46))) {
+      if (returnKind == (3)) {
+        $globals.world.internalError("should not be here", position.span);
+      }
+      var op = TokenKind.kindToString(kind);
+      return new Value(y.get$type(), ("" + x.get$code() + " " + op + "= " + y.get$code()), position.span);
+    }
+    else {
+      var right = x;
+      y = right.binop$4(kind, y, this, position);
+      if (returnKind == (3)) {
+        var tmp = this.forceTemp(x);
+        var ret = new Value(x.get$type(), ("(" + tmp.get$code() + " = " + x.get$code() + ", " + x.get$code() + " = " + y.get$code() + ", " + tmp.get$code() + ")"), position.span);
+        this.freeTemp(tmp);
+        return ret;
+      }
+      else {
+        return new Value(x.get$type(), ("" + x.get$code() + " = " + y.get$code()), position.span);
+      }
+    }
   }
   else {
-    var members = this.method.declaringType.resolveMember(name);
     x = this._makeThisOrType(position.span);
-    if (members != null) {
-      if ($globals.options.forceDynamic && !members.get$isStatic()) {
-        members = this.findMembers(xn.name.name);
-      }
-      if (kind == (0)) {
-        return x.set_$4(this, name, position, y);
-      }
-      else if (!members.get$treatAsField() || members.get$containsMethods()) {
-        var right = x.get_$3(this, name, position);
-        right = captureOriginal(right);
-        y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
-        return x.set_$4(this, name, position, y);
-      }
-      else {
-        x = x.get_$3(this, name, position);
-      }
-    }
-    else {
-      var member = this.get$library().lookup(name, xn.name.span);
-      if (member == null) {
-        $globals.world.warning(("can not resolve " + name), xn.span);
-        return this._makeMissingValue(name);
-      }
-      members = new MemberSet(member, false);
-      if (!members.get$treatAsField() || members.get$containsMethods()) {
-        if (kind != (0)) {
-          var right = members._get$3(this, position, x);
-          right = captureOriginal(right);
-          y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
-        }
-        return members._set$4(this, position, x, y);
-      }
-      else {
-        x = members._get$3(this, position, x);
-      }
-    }
-    y = y.convertTo$2(this, x.get$staticType());
-  }
-  if (x.get$isFinal()) {
-    $globals.world.error(("final variable \"" + x.get$code() + "\" is not assignable"), position.span);
-  }
-  if (kind == (0)) {
-    x = captureOriginal(x);
-    return new Value(y.get$type(), ("" + x.get$code() + " = " + y.get$code()), position.span);
-  }
-  else if (x.get$type().get$isNum() && y.get$type().get$isNum() && (kind != (46))) {
-    x = captureOriginal(x);
-    var op = TokenKind.kindToString(kind);
-    return new Value(y.get$type(), ("" + x.get$code() + " " + op + "= " + y.get$code()), position.span);
-  }
-  else {
-    var right = x;
-    right = captureOriginal(right);
-    y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
-    return new Value(y.get$type(), ("" + x.get$code() + " = " + y.get$code()), position.span);
+    return x.set_$4$kind$returnKind(this, name, position, y, kind, returnKind);
   }
 }
-MethodGenerator.prototype._visitIndexAssign = function(kind, xn, yn, position, captureOriginal, isVoid) {
+MethodGenerator.prototype._visitIndexAssign = function(kind, xn, yn, position, returnKind) {
   var target = this.visitValue(xn.target);
-  var tmptarget = target;
-  if (kind != (0)) tmptarget = this.getTemp(target);
   var index = this.visitValue(xn.index);
-  var tmpindex = index;
-  if (kind != (0)) tmpindex = this.getTemp(index);
   var y = this.visitValue(yn);
-  if (kind != (0)) {
-    index = this.assignTemp(tmpindex, index);
-    var right = tmptarget.invoke$4(this, ":index", position, new Arguments(null, [tmpindex]));
-    right = captureOriginal(right);
-    y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
-  }
-  var tmpy = null;
-  if (!isVoid) {
-    tmpy = this.getTemp(y);
-    y = this.assignTemp(tmpy, y);
-  }
-  var ret = this.assignTemp(tmptarget, target).invoke(this, ":setindex", position, new Arguments(null, [index, y]), false);
-  if (tmpy != null) {
-    ret = new Value(ret.get$type(), ("(" + ret.get$code() + ", " + tmpy.get$code() + ")"), ret.get$span());
-    if ($ne(tmpy, y)) this.freeTemp(tmpy);
-  }
-  if ($ne(tmptarget, target)) this.freeTemp(tmptarget);
-  if ($ne(tmpindex, index)) this.freeTemp(tmpindex);
-  return ret;
+  return target.setIndex$4$kind$returnKind(this, index, position, y, kind, returnKind);
 }
-MethodGenerator.prototype._visitDotAssign = function(kind, xn, yn, position, captureOriginal) {
+MethodGenerator.prototype._visitDotAssign = function(kind, xn, yn, position, returnKind) {
   var target = xn.self.visit(this);
   var y = this.visitValue(yn);
-  var tmptarget = target;
-  if (kind != (0)) {
-    tmptarget = this.getTemp(target);
-    var right = tmptarget.get_$3(this, xn.name.name, xn.name);
-    right = captureOriginal(right);
-    y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
-  }
-  var ret = this.assignTemp(tmptarget, target).set_(this, xn.name.name, xn.name, y, false);
-  if ($ne(tmptarget, target)) this.freeTemp(tmptarget);
-  return ret;
+  return target.set_$4$kind$returnKind(this, xn.name.name, xn.name, y, kind, returnKind);
 }
 MethodGenerator.prototype.visitUnaryExpression = function(node) {
   var value = this.visitValue(node.self);
   switch (node.op.kind) {
     case (16):
     case (17):
 
       if (value.get$type().get$isNum()) {
         return new Value(value.get$type(), ("" + node.op + value.get$code()), node.span);
       }
       else {
         var kind = ((16) == node.op.kind ? (42) : (43));
         var operand = new LiteralExpression(Value.fromInt((1), node.span), node.span);
-        var assignValue = this._visitAssign(kind, node.self, operand, node, to$call$1(null), false);
+        var assignValue = this._visitAssign(kind, node.self, operand, node, (2));
         return new Value(assignValue.get$type(), ("(" + assignValue.get$code() + ")"), node.span);
       }
 
   }
   return value.unop$3(node.op.kind, this, node);
 }
 MethodGenerator.prototype.visitDeclaredIdentifier = function(node) {
   $globals.world.error("Expected expression", node.span);
 }
 MethodGenerator.prototype.visitAwaitExpression = function(node) {
   $globals.world.internalError("Await expressions should have been eliminated before code generation", node.span);
 }
 MethodGenerator.prototype.visitPostfixExpression = function(node, isVoid) {
-  var $this = this; // closure support
   var value = this.visitValue(node.body);
   if (value.get$type().get$isNum() && !value.get$isFinal()) {
     return new Value(value.get$type(), ("" + value.get$code() + node.op), node.span);
   }
   var kind = ((16) == node.op.kind) ? (42) : (43);
   var operand = new LiteralExpression(Value.fromInt((1), node.span), node.span);
-  var tmpleft = null, left = null;
-  var ret = this._visitAssign(kind, node.body, operand, node, (function (l) {
-    if (isVoid) {
-      return l;
-    }
-    else {
-      left = l;
-      tmpleft = $this.forceTemp(l);
-      return $this.assignTemp(tmpleft, left);
-    }
-  })
-  , false);
-  if (tmpleft != null) {
-    ret = new Value(ret.get$type(), ("(" + ret.get$code() + ", " + tmpleft.get$code() + ")"), node.span);
-  }
-  if ($ne(tmpleft, left)) {
-    this.freeTemp(tmpleft);
-  }
+  var ret = this._visitAssign(kind, node.body, operand, node, isVoid ? (1) : (3));
   return ret;
 }
 MethodGenerator.prototype.visitNewExpression = function(node) {
   var typeRef = node.type;
   var constructorName = "";
   if (node.name != null) {
     constructorName = node.name.name;
   }
   if ($eq(constructorName, "") && !(typeRef instanceof GenericTypeReference) && typeRef.get$names() != null) {
     var names = ListFactory.ListFactory$from$factory(typeRef.get$names());
@@ skipping 18 matching lines @@
     }
     $globals.world.error(("no matching constructor for " + name), node.span);
     return this._makeMissingValue(name);
   }
   if (node.isConst) {
     if (!m.get$isConst()) {
       $globals.world.error("can't use const on a non-const constructor", node.span);
     }
     var $$list = node.arguments;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var arg = $$list.$index($$i);
+      var arg = $$list[$$i];
       if (!this.visitValue(arg.get$value()).get$isConst()) {
         $globals.world.error("const constructor expects const arguments", arg.get$span());
       }
     }
   }
   var target = new TypeValue(type, typeRef.get$span());
   return m.invoke$4(this, node, target, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitListExpression = function(node) {
   var argValues = [];
   var listType = $globals.world.listType;
   var type = $globals.world.varType;
   if (node.itemType != null) {
     type = this.method.resolveType$2(node.itemType, true);
     if (node.isConst && ((type instanceof ParameterType) || type.get$hasTypeParams())) {
       $globals.world.error("type parameter cannot be used in const list literals");
     }
     listType = listType.getOrMakeConcreteType$1([type]);
   }
   var $$list = node.values;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var item = $$list.$index($$i);
+    var item = $$list[$$i];
     var arg = this.visitTypedValue(item, type);
     argValues.add$1(arg);
     if (node.isConst && !arg.get$isConst()) {
       $globals.world.error("const list can only contain const values", arg.get$span());
     }
   }
   $globals.world.listFactoryType.markUsed();
   var ret = new ListValue(argValues, node.isConst, listType, node.span);
   if (ret.get$isConst()) return ret.getGlobalValue$0();
   return ret;
@@ skipping 16 matching lines @@
       }
     }
     valueType = this.method.resolveType$2(node.valueType, true);
     if (node.isConst && ((valueType instanceof ParameterType) || valueType.get$hasTypeParams())) {
       $globals.world.error("type parameter cannot be used in const map literals");
     }
     mapType = mapType.getOrMakeConcreteType$1([keyType, valueType]);
   }
   for (var i = (0);
    i < node.items.get$length(); i += (2)) {
-    var key = this.visitTypedValue(node.items.$index(i), keyType);
+    var key = this.visitTypedValue(node.items[i], keyType);
     if (node.isConst && !key.get$isConst()) {
       $globals.world.error("const map can only contain const keys", key.get$span());
     }
     values.add$1(key);
-    var value = this.visitTypedValue(node.items.$index(i + (1)), valueType);
+    var value = this.visitTypedValue(node.items[$add(i, (1))], valueType);
     if (node.isConst && !value.get$isConst()) {
       $globals.world.error("const map can only contain const values", value.get$span());
     }
     values.add$1(value);
   }
   var ret = new MapValue(values, node.isConst, mapType, node.span);
   if (ret.get$isConst()) return ret.getGlobalValue$0();
   return ret;
 }
 MethodGenerator.prototype.visitConditionalExpression = function(node) {
@@ skipping 43 matching lines @@
     return u.op.kind == (16) || u.op.kind == (17);
   }
   else {
     return false;
   }
 }
 MethodGenerator.prototype.visitStringInterpExpression = function(node) {
   var items = [];
   var $$list = node.pieces;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var item = $$list.$index($$i);
+    var item = $$list[$$i];
     var val = this.visitValue(item);
     val.invoke$4(this, "toString", item, Arguments.get$EMPTY());
     var code = val.get$code();
     if (this._expressionNeedsParens(item)) {
       code = ("(" + code + ")");
     }
     if ($eq(items.get$length(), (0)) || ($ne(code, "''") && $ne(code, "\"\""))) {
       items.add$1(code);
     }
   }
   return new Value($globals.world.stringType, ("(" + Strings.join(items, " + ") + ")"), node.span);
 }
 MethodGenerator.prototype._checkNonStatic$1 = MethodGenerator.prototype._checkNonStatic;
 MethodGenerator.prototype._pushBlock$1 = function($0) {
   return this._pushBlock($0, false);
 };
 MethodGenerator.prototype.evalBody$2 = MethodGenerator.prototype.evalBody;
 MethodGenerator.prototype.run$0 = MethodGenerator.prototype.run;
+MethodGenerator.prototype.visitAssertStatement$1 = MethodGenerator.prototype.visitAssertStatement;
 MethodGenerator.prototype.visitBinaryExpression$1 = function($0) {
   return this.visitBinaryExpression($0, false);
 };
+MethodGenerator.prototype.visitBlockStatement$1 = MethodGenerator.prototype.visitBlockStatement;
+MethodGenerator.prototype.visitBreakStatement$1 = MethodGenerator.prototype.visitBreakStatement;
+MethodGenerator.prototype.visitContinueStatement$1 = MethodGenerator.prototype.visitContinueStatement;
+MethodGenerator.prototype.visitDeclaredIdentifier$1 = MethodGenerator.prototype.visitDeclaredIdentifier;
+MethodGenerator.prototype.visitDietStatement$1 = MethodGenerator.prototype.visitDietStatement;
+MethodGenerator.prototype.visitDoStatement$1 = MethodGenerator.prototype.visitDoStatement;
+MethodGenerator.prototype.visitEmptyStatement$1 = MethodGenerator.prototype.visitEmptyStatement;
+MethodGenerator.prototype.visitExpressionStatement$1 = MethodGenerator.prototype.visitExpressionStatement;
+MethodGenerator.prototype.visitForInStatement$1 = MethodGenerator.prototype.visitForInStatement;
+MethodGenerator.prototype.visitForStatement$1 = MethodGenerator.prototype.visitForStatement;
+MethodGenerator.prototype.visitFunctionDefinition$1 = MethodGenerator.prototype.visitFunctionDefinition;
+MethodGenerator.prototype.visitIfStatement$1 = MethodGenerator.prototype.visitIfStatement;
+MethodGenerator.prototype.visitIndexExpression$1 = MethodGenerator.prototype.visitIndexExpression;
+MethodGenerator.prototype.visitLabeledStatement$1 = MethodGenerator.prototype.visitLabeledStatement;
+MethodGenerator.prototype.visitLambdaExpression$1 = MethodGenerator.prototype.visitLambdaExpression;
+MethodGenerator.prototype.visitLiteralExpression$1 = MethodGenerator.prototype.visitLiteralExpression;
+MethodGenerator.prototype.visitMapExpression$1 = MethodGenerator.prototype.visitMapExpression;
+MethodGenerator.prototype.visitNewExpression$1 = MethodGenerator.prototype.visitNewExpression;
 MethodGenerator.prototype.visitPostfixExpression$1 = function($0) {
   return this.visitPostfixExpression($0, false);
 };
+MethodGenerator.prototype.visitReturnStatement$1 = MethodGenerator.prototype.visitReturnStatement;
+MethodGenerator.prototype.visitSwitchStatement$1 = MethodGenerator.prototype.visitSwitchStatement;
+MethodGenerator.prototype.visitThrowStatement$1 = MethodGenerator.prototype.visitThrowStatement;
+MethodGenerator.prototype.visitTryStatement$1 = MethodGenerator.prototype.visitTryStatement;
+MethodGenerator.prototype.visitVariableDefinition$1 = MethodGenerator.prototype.visitVariableDefinition;
+MethodGenerator.prototype.visitWhileStatement$1 = MethodGenerator.prototype.visitWhileStatement;
 MethodGenerator.prototype.writeDefinition$2 = MethodGenerator.prototype.writeDefinition;
 // ********** Code for Arguments **************
 function Arguments(nodes, values) {
   this.nodes = nodes;
   this.values = values;
 }
 Arguments.Arguments$bare$factory = function(arity) {
   var values = [];
   for (var i = (0);
    i < arity; i++) {
@@ skipping 10 matching lines @@
 Arguments.prototype.get$nameCount = function() {
   return this.get$length() - this.get$bareCount();
 }
 Arguments.prototype.get$hasNames = function() {
   return this.get$bareCount() < this.get$length();
 }
 Arguments.prototype.get$length = function() {
   return this.values.get$length();
 }
 Arguments.prototype.getName = function(i) {
-  return this.nodes.$index(i).get$label().get$name();
+  return this.nodes[i].get$label().get$name();
 }
 Arguments.prototype.getIndexOfName = function(name) {
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     if (this.getName(i) == name) {
       return i;
     }
   }
   return (-1);
 }
 Arguments.prototype.getValue = function(name) {
   var i = this.getIndexOfName(name);
-  return i >= (0) ? this.values.$index(i) : null;
+  return i >= (0) ? this.values[i] : null;
 }
 Arguments.prototype.get$bareCount = function() {
   if (this._bareCount == null) {
     this._bareCount = this.get$length();
     if (this.nodes != null) {
       for (var i = (0);
        i < this.nodes.get$length(); i++) {
-        if (this.nodes.$index(i).get$label() != null) {
+        if (this.nodes[i].get$label() != null) {
           this._bareCount = i;
           break;
         }
       }
     }
   }
   return this._bareCount;
 }
 Arguments.prototype.getCode = function() {
   var argsCode = [];
   for (var i = (0);
    i < this.get$length(); i++) {
-    argsCode.add$1(this.values.$index(i).get$code());
+    argsCode.add$1(this.values[i].get$code());
   }
   Arguments.removeTrailingNulls(argsCode);
   return Strings.join(argsCode, ", ");
 }
 Arguments.removeTrailingNulls = function(argsCode) {
-  while (argsCode.get$length() > (0) && $eq(argsCode.last$0(), "null")) {
-    argsCode.removeLast$0();
+  while (argsCode.get$length() > (0) && $eq(argsCode.last(), "null")) {
+    argsCode.removeLast();
   }
 }
 Arguments.prototype.getNames = function() {
   var names = [];
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     names.add$1(this.getName(i));
   }
   return names;
 }
 Arguments.prototype.toCallStubArgs = function() {
   var result = [];
   for (var i = (0);
    i < this.get$bareCount(); i++) {
     result.add$1(new VariableValue($globals.world.varType, ("$" + i), null, false));
   }
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     var name = this.getName(i);
     if (name == null) name = ("$" + i);
     result.add$1(new VariableValue($globals.world.varType, name, null, false));
   }
   return new Arguments(this.nodes, result);
 }
+// ********** Code for ReturnKind **************
+function ReturnKind() {}
 // ********** Code for LibraryImport **************
 function LibraryImport(library, prefix, span) {
   this.library = library;
   this.span = span;
   this.prefix = prefix;
 }
 LibraryImport.prototype.get$prefix = function() { return this.prefix; };
 LibraryImport.prototype.get$library = function() { return this.library; };
 LibraryImport.prototype.get$span = function() { return this.span; };
 // ********** Code for Member **************
@@ skipping 79 matching lines @@
     return $globals.world.nonNullBool;
   }
   return t;
 }
 Member.prototype.get$definition = function() {
   return null;
 }
 Member.prototype.get$parameters = function() {
   return [];
 }
+Member.prototype.get$preciseMemberSet = function() {
+  if (this._preciseMemberSet == null) {
+    this._preciseMemberSet = new MemberSet(this, false);
+  }
+  return this._preciseMemberSet;
+}
+Member.prototype.get$potentialMemberSet = function() {
+  if (this._potentialMemberSet == null) {
+    if (this.declaringType.get$isObject()) {
+      this._potentialMemberSet = $globals.world._members.$index(this.name);
+      return this._potentialMemberSet;
+    }
+    var mems = new HashSetImplementation();
+    if (this.declaringType.get$isClass()) mems.add$1(this);
+    var $$list = this.declaringType.get$subtypes();
+    for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
+      var subtype = $$i.next$0();
+      if (!subtype.get$isClass()) continue;
+      var mem = subtype.get$members().$index(this.name);
+      if (mem != null) {
+        mems.add$1(mem);
+      }
+      else if (!this.declaringType.get$isClass()) {
+        mem = subtype.getMember$1(this.name);
+        if (mem != null) {
+          mems.add$1(mem);
+        }
+      }
+    }
+    if ($ne(mems.get$length(), (0))) {
+      for (var $$i = mems.iterator$0(); $$i.hasNext$0(); ) {
+        var mem = $$i.next$0();
+        if (this._potentialMemberSet == null) {
+          this._potentialMemberSet = new MemberSet(mem, false);
+        }
+        else {
+          this._potentialMemberSet.add(mem);
+        }
+      }
+    }
+  }
+  return this._potentialMemberSet;
+}
 Member.prototype.canInvoke = function(context, args) {
   return this.get$canGet() && new Value(this.get$returnType(), null, null).canInvoke(context, ":call", args);
 }
 Member.prototype.invoke = function(context, node, target, args, isDynamic) {
   var newTarget = this._get(context, node, target, isDynamic);
   return newTarget.invoke$5(context, ":call", node, args, isDynamic);
 }
 Member.prototype.override = function(other) {
   if (this.get$isStatic()) {
     $globals.world.error("static members can not hide parent members", this.get$span(), other.get$span());
@@ skipping 18 matching lines @@
   var typeCode = this.declaringType == null ? (1) : this.declaringType.hashCode();
   var nameCode = this.get$isConstructor() ? this.get$constructorName().hashCode() : this.name.hashCode();
   return (typeCode << (4)) ^ nameCode;
 }
 Member.prototype.$eq = function(other) {
   return (other instanceof Member) && $eq(this.get$isConstructor(), other.get$isConstructor()) && $eq(this.declaringType, other.get$declaringType()) && (this.get$isConstructor() ? this.get$constructorName() == other.get$constructorName() : this.name == other.get$name());
 }
 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;
@@ skipping 78 matching lines @@
 Library.prototype._addMember = function(member) {
   if (member.get$isPrivate()) {
     if (member.get$isStatic()) {
       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$0();
+      var $$list = $globals.world.libraries.getValues();
       for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
         var lib = $$i.next$0();
         if (lib.get$_privateMembers().containsKey$1(member.get$jsname())) {
           member._jsname = ("_" + this.get$jsname() + member.get$jsname());
           break;
         }
       }
       mset = new MemberSet(member, true);
       this._privateMembers.$setindex(member.name, mset);
     }
@@ skipping 33 matching lines @@
 Library.prototype.findType = function(type) {
   var result = this.findTypeByName(type.name.name);
   if (result == null) return null;
   if (type.names != null) {
     if (type.names.get$length() > (1)) {
       return null;
     }
     if (!result.get$isTop()) {
       return null;
     }
-    return result.get$library().findTypeByName(type.names.$index((0)).get$name());
+    return result.get$library().findTypeByName(type.names[(0)].get$name());
   }
   return result;
 }
 Library.prototype.findTypeByName = function(name) {
   var ret = this.types.$index(name);
   var $$list = this.imports;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var imported = $$list.$index($$i);
+    var imported = $$list[$$i];
     var newRet = null;
     if (imported.get$prefix() == null) {
       newRet = imported.get$library().get$types().$index(name);
     }
     else if ($eq(imported.get$prefix(), name)) {
       newRet = imported.get$library().get$topType();
     }
     if (newRet != null) {
       if (ret != null && $ne(ret, newRet)) {
         $globals.world.error(("conflicting types for \"" + name + "\""), ret.get$span(), newRet.get$span());
@@ skipping 43 matching lines @@
     var index = this.name.lastIndexOf("/", this.name.length);
     if (index >= (0)) {
       this.name = this.name.substring($add(index, (1)));
     }
     index = this.name.indexOf(".");
     if (index > (0)) {
       this.name = this.name.substring((0), index);
     }
   }
   this._jsname = this.name.replaceAll(".", "_").replaceAll(":", "_").replaceAll(" ", "_");
-  var $$list = this.types.getValues$0();
+  var $$list = this.types.getValues();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var type = $$i.next$0();
     type.resolve$0();
   }
 }
 Library.prototype._addTopName = function(name, member, localSpan) {
   var existing = this._topNames.$index(name);
   if (existing == null) {
     this._topNames.$setindex(name, member);
   }
   else {
     if ((existing instanceof AmbiguousMember)) {
       existing.get$members().add$1(member);
     }
     else {
       var newMember = new AmbiguousMember(name, [existing, member]);
       $globals.world.error(("conflicting members for \"" + name + "\""), existing.get$span(), member.get$span(), localSpan);
       this._topNames.$setindex(name, newMember);
     }
   }
 }
 Library.prototype._addTopNames = function(lib) {
-  var $$list = lib.topType.members.getValues$0();
+  var $$list = lib.topType.members.getValues();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var member = $$i.next$0();
     if (member.get$isPrivate() && $ne(lib, this)) continue;
     this._addTopName(member.get$name(), member);
   }
-  var $$list = lib.types.getValues$0();
+  var $$list = lib.types.getValues();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var type = $$i.next$0();
     if (!type.get$isTop()) {
       if ($ne(lib, this) && type.get$typeMember().get$isPrivate()) continue;
       this._addTopName(type.get$name(), type.get$typeMember());
     }
   }
 }
 Library.prototype.postResolveChecks = function() {
   this._topNames = new HashMapImplementation();
   this._addTopNames(this);
   var $$list = this.imports;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var imported = $$list.$index($$i);
+    var imported = $$list[$$i];
     if (imported.get$prefix() == null) {
       this._addTopNames(imported.get$library());
     }
     else {
       this._addTopName(imported.get$prefix(), imported.get$library().get$topType().get$typeMember(), imported.get$span());
     }
   }
 }
 Library.prototype.visitSources = function() {
   var visitor = new _LibraryVisitor(this);
@@ skipping 150 matching lines @@
 _LibraryVisitor.prototype.getSingleStringArg = function(node) {
   if (node.arguments.get$length() != (1)) {
     $globals.world.error(("expected exactly one argument but found " + node.arguments.get$length()), node.span);
   }
   return this.getFirstStringArg(node);
 }
 _LibraryVisitor.prototype.getFirstStringArg = function(node) {
   if (node.arguments.get$length() < (1)) {
     $globals.world.error(("expected at least one argument but found " + node.arguments.get$length()), node.span);
   }
-  var arg = node.arguments.$index((0));
+  var arg = node.arguments[(0)];
   if (arg.get$label() != null) {
     $globals.world.error("label not allowed for directive", node.span);
   }
   return this._parseStringArgument(arg);
 }
 _LibraryVisitor.prototype.tryGetNamedStringArg = function(node, argName) {
   var args = node.arguments.filter$1((function (a) {
     return a.get$label() != null && $eq(a.get$label().get$name(), argName);
   })
   );
@@ skipping 13 matching lines @@
   if (!(expr instanceof LiteralExpression) || !expr.get$value().get$type().get$isString()) {
     $globals.world.error("expected string literal", expr.get$span());
   }
   return expr.get$value().get$actualValue();
 }
 _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.get$length(); $$i++) {
-    var member = $$list.$index($$i);
+    var member = $$list[$$i];
     member.visit$1(this);
   }
   this.currentType = oldType;
 }
 _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$2(":call", node.func);
 }
 _LibraryVisitor.prototype.addSource$1 = _LibraryVisitor.prototype.addSource;
+_LibraryVisitor.prototype.visitFunctionDefinition$1 = _LibraryVisitor.prototype.visitFunctionDefinition;
+_LibraryVisitor.prototype.visitVariableDefinition$1 = _LibraryVisitor.prototype.visitVariableDefinition;
 // ********** Code for Parameter **************
 function Parameter(definition, method) {
   this.method = method;
   this.definition = definition;
   this.isInitializer = false;
 }
 Parameter.prototype.get$definition = function() { return this.definition; };
 Parameter.prototype.set$definition = function(value) { return this.definition = value; };
 Parameter.prototype.get$method = function() { return this.method; };
 Parameter.prototype.set$method = function(value) { return this.method = value; };
@@ skipping 90 matching lines @@
   $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 **************
 $inherits(FieldMember, Member);
@@ skipping 44 matching lines @@
 }
 FieldMember.prototype.get$isField = function() {
   return true;
 }
 FieldMember.prototype.resolve = function() {
   this.isStatic = this.declaringType.get$isTop();
   this.isFinal = false;
   if (this.definition.modifiers != null) {
     var $$list = this.definition.modifiers;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var mod = $$list.$index($$i);
+      var mod = $$list[$$i];
       if ($eq(mod.get$kind(), (85))) {
         if (this.isStatic) {
           $globals.world.error("duplicate static modifier", mod.get$span());
         }
         this.isStatic = true;
       }
       else if ($eq(mod.get$kind(), (99))) {
         if (this.isFinal) {
           $globals.world.error("duplicate final modifier", mod.get$span());
         }
         this.isFinal = true;
       }
       else {
         $globals.world.error(("" + mod + " modifier not allowed on field"), mod.get$span());
       }
     }
   }
-  this.type = this.resolveType(this.definition.type, false);
+  this.type = this.resolveType$2(this.definition.type, false);
   if (this.isStatic && !this.get$isFactory() && this.type.get$hasTypeParams()) {
     $globals.world.error("using type parameter in static context", this.definition.type.span);
   }
   if (this.isStatic && this.isFinal && this.value == null) {
     $globals.world.error("static final field is missing initializer", this.get$span());
   }
   this.get$library()._addMember(this);
 }
 FieldMember.prototype.computeValue = function() {
   if (this.value == null) return null;
@@ skipping 67 matching lines @@
 FieldMember.prototype._set = function(context, node, target, value, isDynamic) {
   var lhs = this._get(context, node, target, isDynamic);
   value = value.convertTo(context, this.type, isDynamic);
   return new Value(this.type, ("" + lhs.get$code() + " = " + value.get$code()), node.span);
 }
 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 **************
 $inherits(PropertyMember, Member);
 function PropertyMember(name, declaringType) {
   Member.call(this, name, declaringType);
@@ skipping 92 matching lines @@
       $globals.world.warning("setter methods should be void", this.setter.definition.returnType.span);
     }
   }
   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 **************
 $inherits(ConcreteMember, Member);
 function ConcreteMember(name, declaringType, baseMember) {
   this.baseMember = baseMember;
   Member.call(this, name, declaringType);
   this.parameters = [];
   this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType);
   var $$list = this.baseMember.get$parameters();
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var p = $$list.$index($$i);
+    var p = $$list[$$i];
     var newType = p.get$type().resolveTypeParams$1(declaringType);
     if ($ne(newType, p.get$type())) {
       this.parameters.add(p.copyWithNewType$2(this, newType));
     }
     else {
       this.parameters.add(p);
     }
   }
 }
 ConcreteMember.prototype.get$returnType = function() { return this.returnType; };
@@ skipping 100 matching lines @@
     this.declaringType.genMethod(this);
   }
   return new Value(this.get$inferredResult(), code, node.span);
 }
 ConcreteMember.prototype._evalConstConstructor$2 = ConcreteMember.prototype._evalConstConstructor;
 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;
@@ skipping 83 matching lines @@
     return false;
   }
 }
 MethodMember.prototype.canInvoke = function(context, args) {
   var bareCount = args.get$bareCount();
   if (bareCount > this.parameters.get$length()) return false;
   if (bareCount == this.parameters.get$length()) {
     if (bareCount != args.get$length()) return false;
   }
   else {
-    if (!this.parameters.$index(bareCount).get$isOptional()) return false;
+    if (!this.parameters[bareCount].get$isOptional()) return false;
     for (var i = bareCount;
      i < args.get$length(); i++) {
       if (this.indexOfParameter(args.getName(i)) < (0)) {
         return false;
       }
     }
   }
   return true;
 }
 MethodMember.prototype.indexOfParameter = function(name) {
   for (var i = (0);
    i < this.parameters.get$length(); i++) {
-    var p = this.parameters.$index(i);
+    var p = this.parameters[i];
     if (p.get$isOptional() && $eq(p.get$name(), name)) {
       return i;
     }
   }
   return (-1);
 }
 MethodMember.prototype.provideFieldSyntax = function() {
   this._provideFieldSyntax = true;
 }
 MethodMember.prototype.providePropertySyntax = function() {
@@ skipping 13 matching lines @@
   this._providePropertySyntax = true;
   return new Value(this.get$functionType(), ("" + target.get$code() + ".get$" + this.get$jsname() + "()"), node.span);
 }
 MethodMember.prototype.namesInHomePositions = function(args) {
   if (!args.get$hasNames()) return true;
   for (var i = args.get$bareCount();
    i < args.values.get$length(); i++) {
     if (i >= this.parameters.get$length()) {
       return false;
     }
-    if (args.getName(i) != this.parameters.$index(i).get$name()) {
+    if (args.getName(i) != this.parameters[i].get$name()) {
       return false;
     }
   }
   return true;
 }
 MethodMember.prototype.namesInOrder = function(args) {
   if (!args.get$hasNames()) return true;
   var lastParameter = null;
   for (var i = args.get$bareCount();
    i < this.parameters.get$length(); i++) {
-    var p = args.getIndexOfName(this.parameters.$index(i).get$name());
-    if (p >= (0) && args.values.$index(p).get$needsTemp()) {
+    var p = args.getIndexOfName(this.parameters[i].get$name());
+    if (p >= (0) && args.values[p].get$needsTemp()) {
       if (lastParameter != null && lastParameter > p) {
         return false;
       }
       lastParameter = p;
     }
   }
   return true;
 }
 MethodMember.prototype.needsArgumentConversion = function(args) {
   var bareCount = args.get$bareCount();
   for (var i = (0);
    i < bareCount; i++) {
-    var arg = args.values.$index(i);
-    if (arg.needsConversion$1(this.parameters.$index(i).get$type())) {
+    var arg = args.values[i];
+    if (arg.needsConversion$1(this.parameters[i].get$type())) {
       return true;
     }
   }
   if (bareCount < this.parameters.get$length()) {
     this.genParameterValues();
     for (var i = bareCount;
      i < this.parameters.get$length(); i++) {
-      var arg = args.getValue(this.parameters.$index(i).get$name());
-      if (arg != null && arg.needsConversion$1(this.parameters.$index(i).get$type())) {
+      var arg = args.getValue(this.parameters[i].get$name());
+      if (arg != null && arg.needsConversion$1(this.parameters[i].get$type())) {
         return true;
       }
     }
   }
   return false;
 }
 MethodMember._argCountMsg = function(actual, expected, atLeast) {
   return "wrong number of positional arguments, expected " + ("" + (atLeast ? "at least " : "") + expected + " but found " + actual);
 }
 MethodMember.prototype._argError = function(context, node, target, args, msg, argIndex) {
   var span;
   if ((args.nodes == null) || (argIndex >= args.nodes.get$length())) {
     span = node.span;
   }
   else {
-    span = args.nodes.$index(argIndex).get$span();
+    span = args.nodes[argIndex].get$span();
   }
   if (this.isStatic || this.get$isConstructor()) {
     $globals.world.error(msg, span);
   }
   else {
     $globals.world.warning(msg, span);
   }
   return target.invokeNoSuchMethod(context, this.name, node, args);
 }
 MethodMember.prototype.genParameterValues = function() {
   var $$list = this.parameters;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var p = $$list.$index($$i);
+    var p = $$list[$$i];
     p.genValue$2(this, this.generator);
   }
 }
 MethodMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   if (this.parameters == null) {
     $globals.world.info(("surprised to need to resolve: " + this.declaringType.name + "." + this.name));
     this.resolve();
   }
   this.declaringType.genMethod(this);
   if (this.isStatic || this.isFactory) {
     this.declaringType.markUsed();
   }
   if (this.get$isNative() && this.returnType != null) this.returnType.markUsed();
   if (!this.namesInOrder(args)) {
     return context.findMembers(this.name).invokeOnVar(context, node, target, args);
   }
   var argsCode = [];
   if (!target.get$isType() && (this.get$isConstructor() || target.get$isSuper())) {
     argsCode.add$1("this");
   }
   var bareCount = args.get$bareCount();
   for (var i = (0);
    i < bareCount; i++) {
-    var arg = args.values.$index(i);
+    var arg = args.values[i];
     if (i >= this.parameters.get$length()) {
       var msg = MethodMember._argCountMsg(args.get$length(), this.parameters.get$length(), false);
       return this._argError(context, node, target, args, msg, i);
     }
-    arg = arg.convertTo$3(context, this.parameters.$index(i).get$type(), isDynamic);
+    arg = arg.convertTo$3(context, this.parameters[i].get$type(), isDynamic);
     argsCode.add$1(arg.get$code());
   }
   var namedArgsUsed = (0);
   if (bareCount < this.parameters.get$length()) {
     this.genParameterValues();
     for (var i = bareCount;
      i < this.parameters.get$length(); i++) {
-      var arg = args.getValue(this.parameters.$index(i).get$name());
+      var arg = args.getValue(this.parameters[i].get$name());
       if (arg == null) {
-        arg = this.parameters.$index(i).get$value();
+        arg = this.parameters[i].get$value();
       }
       else {
-        arg = arg.convertTo$3(context, this.parameters.$index(i).get$type(), isDynamic);
+        arg = arg.convertTo$3(context, this.parameters[i].get$type(), isDynamic);
         namedArgsUsed++;
       }
-      if (arg == null || !this.parameters.$index(i).get$isOptional()) {
-        var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + (1), true);
+      if (arg == null || !this.parameters[i].get$isOptional()) {
+        var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), $add(i, (1)), true);
         return this._argError(context, node, target, args, msg, i);
       }
       else {
         argsCode.add$1(arg.get$code());
       }
     }
     Arguments.removeTrailingNulls(argsCode);
   }
   if (namedArgsUsed < args.get$nameCount()) {
     var seen = new HashSetImplementation();
@@ skipping 134 matching lines @@
   return new Value(this.get$inferredResult(), ("" + target.get$code() + "." + this.get$jsname() + "(" + argsString + ")"), node.span);
 }
 MethodMember.prototype.resolve = function() {
   this.isStatic = this.declaringType.get$isTop();
   this.isConst = false;
   this.isFactory = false;
   this.isAbstract = !this.declaringType.get$isClass();
   if (this.definition.modifiers != null) {
     var $$list = this.definition.modifiers;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var mod = $$list.$index($$i);
+      var mod = $$list[$$i];
       if ($eq(mod.get$kind(), (85))) {
         if (this.isStatic) {
           $globals.world.error("duplicate static modifier", mod.get$span());
         }
         this.isStatic = true;
       }
       else if (this.get$isConstructor() && $eq(mod.get$kind(), (92))) {
         if (this.isConst) {
           $globals.world.error("duplicate const modifier", mod.get$span());
         }
@@ skipping 51 matching lines @@
   }
   if (this.get$isConstructor() && !this.isFactory) {
     this.returnType = this.declaringType;
   }
   else {
     this.returnType = this.resolveType(this.definition.returnType, false, true);
   }
   this.parameters = [];
   var $$list = this.definition.formals;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var formal = $$list.$index($$i);
+    var formal = $$list[$$i];
     var param = new Parameter(formal, this);
     param.resolve$0();
     this.parameters.add(param);
   }
   if (!this.isLambda) {
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype.resolveType = function(node, typeErrors, allowVoid) {
   var t = Element.prototype.resolveType.call(this, node, typeErrors);
   if (this.isStatic && !this.isFactory && (t instanceof ParameterType)) {
     $globals.world.error("using type parameter in static context.", node.span);
   }
   if (!allowVoid && t.get$isVoid()) {
     $globals.world.error("\"void\" only allowed as return type", node.span);
   }
   return t;
 }
 MethodMember.prototype._evalConstConstructor$2 = MethodMember.prototype._evalConstConstructor;
 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;
 MethodMember.prototype.resolveType$2 = function($0, $1) {
   return this.resolveType($0, $1, false);
 };
 // ********** Code for MemberSet **************
 function MemberSet(member, isVar) {
   this.jsname = member.get$jsname();
   this.name = member.name;
   this.isVar = isVar;
   this.members = [member];
 }
 MemberSet.prototype.get$name = function() { return this.name; };
 MemberSet.prototype.get$members = function() { return this.members; };
 MemberSet.prototype.get$jsname = function() { return this.jsname; };
 MemberSet.prototype.get$isVar = function() { return this.isVar; };
 MemberSet.prototype.toString = function() {
   return ("" + this.name + ":" + this.members.get$length());
 }
-MemberSet.prototype.get$containsMethods = function() {
-  return this.members.some((function (m) {
-    return (m instanceof MethodMember);
-  })
-  );
-}
 MemberSet.prototype.add = function(member) {
   return this.members.add(member);
 }
 MemberSet.prototype.get$isStatic = function() {
-  return this.members.get$length() == (1) && this.members.$index((0)).get$isStatic();
+  return this.members.get$length() == (1) && this.members[(0)].get$isStatic();
 }
 MemberSet.prototype.get$isOperator = function() {
-  return this.members.$index((0)).get$isOperator();
+  return this.members[(0)].get$isOperator();
 }
 MemberSet.prototype.canInvoke = function(context, args) {
   return this.members.some((function (m) {
     return m.canInvoke$2(context, args);
   })
   );
 }
 MemberSet.prototype._makeError = function(node, target, action) {
   if (!target.get$type().get$isVar()) {
     $globals.world.warning(("could not find applicable " + action + " for \"" + this.name + "\""), node.span);
   }
   return new Value($globals.world.varType, ("" + target.get$code() + "." + this.jsname + "() /*no applicable " + action + "*/"), node.span);
 }
 MemberSet.prototype.get$treatAsField = function() {
   if (this._treatAsField == null) {
     this._treatAsField = !this.isVar && (this.members.some((function (m) {
       return m.get$requiresFieldSyntax();
     })
     ) || this.members.every((function (m) {
       return !m.get$requiresPropertySyntax();
     })
     ));
     var $$list = this.members;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var member = $$list.$index($$i);
+      var member = $$list[$$i];
       if (this._treatAsField) {
         member.provideFieldSyntax$0();
       }
       else {
         member.providePropertySyntax$0();
       }
     }
   }
   return this._treatAsField;
 }
 MemberSet.prototype._get = function(context, node, target, isDynamic) {
   var returnValue;
+  if (this.members.get$length() == (1) && !this.isVar) {
+    return this.members[(0)]._get$4(context, node, target, isDynamic);
+  }
   var targets = this.members.filter$1((function (m) {
     return m.get$canGet();
   })
   );
   if (this.isVar) {
     targets.forEach$1((function (m) {
       return m._get$3$isDynamic(context, node, target, true);
     })
     );
     returnValue = new Value(this._foldTypes(targets), null, node.span);
   }
   else {
     if (this.members.get$length() == (1)) {
-      return this.members.$index((0))._get$4(context, node, target, isDynamic);
+      return this.members[(0)]._get$4(context, node, target, isDynamic);
     }
     else if ($eq(targets.get$length(), (1))) {
       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$3$isDynamic(context, node, target, true);
       returnValue = this._tryUnion(returnValue, value, node);
     }
     if (returnValue == null) {
       return this._makeError(node, target, "getter");
     }
   }
   if (returnValue.get$code() == null) {
     if (this.get$treatAsField()) {
       return new Value(returnValue.get$type(), ("" + target.get$code() + "." + this.jsname), node.span);
     }
     else {
       return new Value(returnValue.get$type(), ("" + target.get$code() + ".get$" + this.jsname + "()"), node.span);
     }
   }
   return returnValue;
 }
 MemberSet.prototype._set = function(context, node, target, value, isDynamic) {
+  if (this.members.get$length() == (1) && !this.isVar) {
+    return this.members[(0)]._set$5(context, node, target, value, isDynamic);
+  }
   var returnValue;
   var targets = this.members.filter$1((function (m) {
     return m.get$canSet();
   })
   );
   if (this.isVar) {
     targets.forEach$1((function (m) {
       return m._set$4$isDynamic(context, node, target, value, true);
     })
     );
     returnValue = new Value(this._foldTypes(targets), null, node.span);
   }
   else {
     if (this.members.get$length() == (1)) {
-      return this.members.$index((0))._set$5(context, node, target, value, isDynamic);
+      return this.members[(0)]._set$5(context, node, target, value, isDynamic);
     }
     else if ($eq(targets.get$length(), (1))) {
       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$4$isDynamic(context, node, target, value, true);
       returnValue = this._tryUnion(returnValue, res, node);
     }
     if (returnValue == null) {
       return this._makeError(node, target, "setter");
     }
   }
   if (returnValue.get$code() == null) {
     if (this.get$treatAsField()) {
       return new Value(returnValue.get$type(), ("" + target.get$code() + "." + this.jsname + " = " + value.get$code()), node.span);
     }
     else {
       return new Value(returnValue.get$type(), ("" + target.get$code() + ".set$" + this.jsname + "(" + value.get$code() + ")"), node.span);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invoke = function(context, node, target, args, isDynamic) {
   if (this.isVar && !this.get$isOperator()) {
     return this.invokeOnVar(context, node, target, args);
   }
-  if (this.members.get$length() == (1)) {
-    return this.members.$index((0)).invoke$5(context, node, target, args, isDynamic);
+  if (this.members.get$length() == (1) && !this.isVar) {
+    return this.members[(0)].invoke$5(context, node, target, args, isDynamic);
   }
   var targets = this.members.filter$1((function (m) {
     return m.canInvoke$2(context, args);
   })
   );
   if ($eq(targets.get$length(), (1))) {
     return targets.$index((0)).invoke$5(context, node, target, args, isDynamic);
   }
   var returnValue = null;
-  for (var $$i = targets.iterator$0(); $$i.hasNext$0(); ) {
-    var member = $$i.next$0();
-    var res = member.invoke$4$isDynamic(context, node, target, args, true);
-    returnValue = this._tryUnion(returnValue, res, node);
+  if (targets.get$length() < (1000)) {
+    for (var $$i = targets.iterator$0(); $$i.hasNext$0(); ) {
+      var member = $$i.next$0();
+      var res = member.invoke$4$isDynamic(context, node, target, args, true);
+      returnValue = this._tryUnion(returnValue, res, node);
+    }
+    if (returnValue == null) {
+      return this._makeError(node, target, "method");
+    }
   }
-  if (returnValue == null) {
-    return this._makeError(node, target, "method");
+  else {
+    returnValue = new Value($globals.world.varType, null, node.span);
   }
   if (returnValue.get$code() == null) {
     if (this.name == ":call") {
       return target._varCall(context, node, args);
     }
     else if (this.get$isOperator()) {
       return this.invokeSpecial(target, args, returnValue.get$type());
     }
     else {
       return this.invokeOnVar(context, node, target, args);
@@ skipping 56 matching lines @@
   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;
@@ skipping 11 matching lines @@
 }
 FactoryMap.prototype.addFactory = function(typeName, name, member) {
   this.getFactoriesFor(typeName).$setindex(name, member);
 }
 FactoryMap.prototype.getFactory = function(typeName, name) {
   return this.getFactoriesFor(typeName).$index(name);
 }
 FactoryMap.prototype.forEach = function(f) {
   this.factories.forEach((function (_, constructors) {
     constructors.forEach((function (_, member) {
-      f(member);
+      f.call$1(member);
     })
     );
   })
   );
 }
 FactoryMap.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 FactoryMap.prototype.getFactory$2 = FactoryMap.prototype.getFactory;
 // ********** Code for Token **************
@@ skipping 57 matching lines @@
 SourceFile.prototype.get$orderInLibrary = function() { return this.orderInLibrary; };
 SourceFile.prototype.set$orderInLibrary = function(value) { return this.orderInLibrary = value; };
 SourceFile.prototype.get$text = function() {
   return this._text;
 }
 SourceFile.prototype.get$lineStarts = function() {
   if (this._lineStarts == null) {
     var starts = [(0)];
     var index = (0);
     while (index < this.get$text().length) {
-      index = this.get$text().indexOf("\n", index) + (1);
+      index = $add(this.get$text().indexOf("\n", index), (1));
       if (index <= (0)) break;
       starts.add$1(index);
     }
-    starts.add$1(this.get$text().length + (1));
+    starts.add$1($add(this.get$text().length, (1)));
     this._lineStarts = starts;
   }
   return this._lineStarts;
 }
 SourceFile.prototype.getLine = function(position) {
   var starts = this.get$lineStarts();
   for (var i = (0);
    i < starts.get$length(); i++) {
     if (starts.$index(i) > position) return i - (1);
   }
   $globals.world.internalError("bad position");
 }
 SourceFile.prototype.getColumn = function(line, position) {
-  return position - this.get$lineStarts().$index(line);
+  return position - this.get$lineStarts()[line];
 }
 SourceFile.prototype.getLocationMessage = function(message, start, end, includeText) {
   var line = this.getLine(start);
   var column = this.getColumn(line, start);
   var buf = new StringBufferImpl(("" + this.filename + ":" + ($add(line, (1))) + ":" + ($add(column, (1))) + ": " + message));
   if (includeText) {
     buf.add$1("\n");
     var textLine;
     if (($add(line, (2))) < this._lineStarts.get$length()) {
-      textLine = this.get$text().substring(this._lineStarts.$index(line), this._lineStarts.$index($add(line, (1))));
+      textLine = this.get$text().substring(this._lineStarts[line], this._lineStarts[$add(line, (1))]);
     }
     else {
-      textLine = this.get$text().substring(this._lineStarts.$index(line)) + "\n";
+      textLine = this.get$text().substring(this._lineStarts[line]) + "\n";
     }
     var toColumn = Math.min($add(column, (end - start)), textLine.get$length());
     if ($globals.options.useColors) {
       buf.add$1(textLine.substring$2((0), column));
       buf.add$1($globals._RED_COLOR);
       buf.add$1(textLine.substring$2(column, toColumn));
       buf.add$1($globals._NO_COLOR);
       buf.add$1(textLine.substring$1(toColumn));
     }
     else {
@@ skipping 234 matching lines @@
   else {
     return (-1);
   }
 }
 TokenizerBase.prototype.readHex = function(hexLength) {
   var maxIndex;
   if (hexLength == null) {
     maxIndex = this._text.length - (1);
   }
   else {
-    maxIndex = this._lang_index + hexLength;
+    maxIndex = $add(this._lang_index, hexLength);
     if (maxIndex >= this._text.length) return (-1);
   }
   var result = (0);
   while (this._lang_index < maxIndex) {
     var digit = TokenizerBase._hexDigit(this._text.charCodeAt(this._lang_index));
     if ($eq(digit, (-1))) {
       if (hexLength == null) {
         return result;
       }
       else {
         return (-1);
       }
     }
     TokenizerBase._hexDigit(this._text.charCodeAt(this._lang_index));
-    result = (result * (16)) + digit;
+    result = $add((result * (16)), digit);
     this._lang_index++;
   }
   return result;
 }
 TokenizerBase.prototype.finishHex = function() {
   var value = this.readHex();
   return new LiteralToken((61), this._source, this._startIndex, this._lang_index, value);
 }
 TokenizerBase.prototype.finishNumber = function() {
   this.eatDigits();
@@ skipping 23 matching lines @@
   return this._finishToken(kind);
 }
 TokenizerBase.prototype._makeStringToken = function(buf, isPart) {
   var s = Strings.String$fromCharCodes$factory(buf);
   var kind = isPart ? (59) : (58);
   return new LiteralToken(kind, this._source, this._startIndex, this._lang_index, s);
 }
 TokenizerBase.prototype._makeRawStringToken = function(isMultiline) {
   var s;
   if (isMultiline) {
-    var start = this._startIndex + (4);
+    var start = $add(this._startIndex, (4));
     if (this._source.get$text()[start] == "\n") start++;
     s = this._source.get$text().substring(start, this._lang_index - (3));
   }
   else {
-    s = this._source.get$text().substring(this._startIndex + (2), this._lang_index - (1));
+    s = this._source.get$text().substring($add(this._startIndex, (2)), this._lang_index - (1));
   }
   return new LiteralToken((58), this._source, this._startIndex, this._lang_index, s);
 }
 TokenizerBase.prototype.finishMultilineString = function(quote) {
   var buf = [];
   while (true) {
     var ch = this._nextChar();
     if (ch == (0)) {
       return this._errorToken();
     }
@@ skipping 24 matching lines @@
     }
   }
 }
 TokenizerBase.prototype._finishOpenBrace = function() {
   var $0;
   if (this._interpStack != null) {
     if (this._interpStack.depth == (-1)) {
       this._interpStack.depth = (1);
     }
     else {
-      ($0 = this._interpStack).depth = $0.depth + (1);
+      ($0 = this._interpStack).depth = $add($0.depth, (1));
     }
   }
   return this._finishToken((6));
 }
 TokenizerBase.prototype._finishCloseBrace = function() {
   var $0;
   if (this._interpStack != null) {
     ($0 = this._interpStack).depth = $0.depth - (1);
   }
   return this._finishToken((7));
@@ skipping 1190 matching lines @@
     case (115):
 
       return "keyword 'void'";
 
     case (116):
 
       return "keyword 'while'";
 
     default:
 
-      return "TokenKind(" + kind.toString() + ")";
+      return "TokenKind(" + kind.toString$0() + ")";
 
   }
 }
 TokenKind.isIdentifier = function(kind) {
   return kind >= (70) && kind < (87);
 }
 TokenKind.infixPrecedence = function(kind) {
   switch (kind) {
     case (20):
 
@@ skipping 317 matching lines @@
 
     case (57):
 
       return ":setindex";
 
   }
 }
 TokenKind.kindFromAssign = function(kind) {
   if (kind == (20)) return (0);
   if (kind > (20) && kind <= (32)) {
-    return kind + (15);
+    return $add(kind, (15));
   }
   return (-1);
 }
 // ********** Code for Parser **************
 function Parser(source, diet, throwOnIncomplete, optionalSemicolons, startOffset) {
   this.throwOnIncomplete = throwOnIncomplete;
   this.source = source;
   this.optionalSemicolons = optionalSemicolons;
   this._recover = false;
   this._inhibitLambda = false;
@@ skipping 1050 matching lines @@
   if (this._inhibitLambda) return false;
   var after = this._peekAfterCloseParen();
   return after.kind == (9) || after.kind == (6);
 }
 Parser.prototype._eatLeftParen = function() {
   this._eat((2));
   this._afterParensIndex++;
 }
 Parser.prototype._peekAfterCloseParen = function() {
   if (this._afterParensIndex < this._afterParens.get$length()) {
-    return this._afterParens.$index(this._afterParensIndex);
+    return this._afterParens[this._afterParensIndex];
   }
   this._afterParensIndex = (0);
   this._afterParens.clear();
   var tokens = [this._lang_next()];
   this._lookaheadAfterParens(tokens);
   var after = this._peekToken;
   tokens.add$1(after);
   this.tokenizer = new DivertedTokenSource(tokens, this, this.tokenizer);
   this._lang_next();
   return after;
@@ skipping 249 matching lines @@
     return depth;
   }
 }
 Parser.prototype.addTypeArguments = function(baseType, depth) {
   this._eat((52));
   return this._finishTypeArguments(baseType, depth, []);
 }
 Parser.prototype._finishTypeArguments = function(baseType, depth, types) {
   var delta = (-1);
   do {
-    var myType = this.type(depth + (1));
+    var myType = this.type($add(depth, (1)));
     types.add$1(myType);
     if ((myType instanceof GenericTypeReference) && myType.get$depth() <= depth) {
       delta = depth - myType.get$depth();
       break;
     }
   }
   while (this._maybeEat((11)))
   if (delta >= (0)) {
     depth = depth - delta;
   }
@@ skipping 180 matching lines @@
 }
 IncompleteSourceException.prototype.toString$0 = IncompleteSourceException.prototype.toString;
 // ********** Code for DivertedTokenSource **************
 function DivertedTokenSource(tokens, parser, previousTokenizer) {
   this.parser = parser;
   this._lang_pos = (0);
   this.tokens = tokens;
   this.previousTokenizer = previousTokenizer;
 }
 DivertedTokenSource.prototype.next = function() {
-  var token = this.tokens.$index(this._lang_pos);
+  var token = this.tokens[this._lang_pos];
   ++this._lang_pos;
   if (this._lang_pos == this.tokens.get$length()) {
     this.parser.tokenizer = this.previousTokenizer;
   }
   return token;
 }
 DivertedTokenSource.prototype.next$0 = DivertedTokenSource.prototype.next;
 // ********** Code for Node **************
 function Node(span) {
   this.span = span;
@@ skipping 99 matching lines @@
   this.type = type;
   this.names = names;
   this.values = values;
   Definition.call(this, span);
 }
 VariableDefinition.prototype.get$type = function() { return this.type; };
 VariableDefinition.prototype.set$type = function(value) { return this.type = value; };
 VariableDefinition.prototype.get$names = function() { return this.names; };
 VariableDefinition.prototype.set$names = function(value) { return this.names = value; };
 VariableDefinition.prototype.visit = function(visitor) {
-  return visitor.visitVariableDefinition(this);
+  return visitor.visitVariableDefinition$1(this);
 }
 VariableDefinition.prototype.visit$1 = VariableDefinition.prototype.visit;
 // ********** Code for FunctionDefinition **************
 $inherits(FunctionDefinition, Definition);
 function FunctionDefinition(modifiers, returnType, name, formals, initializers, nativeBody, body, span) {
   this.modifiers = modifiers;
   this.name = name;
   this.initializers = initializers;
   this.body = body;
   this.returnType = returnType;
   this.formals = formals;
   this.nativeBody = nativeBody;
   Definition.call(this, span);
 }
 FunctionDefinition.prototype.get$returnType = function() { return this.returnType; };
 FunctionDefinition.prototype.set$returnType = function(value) { return this.returnType = value; };
 FunctionDefinition.prototype.get$name = function() { return this.name; };
 FunctionDefinition.prototype.set$name = function(value) { return this.name = value; };
 FunctionDefinition.prototype.get$initializers = function() { return this.initializers; };
 FunctionDefinition.prototype.set$initializers = function(value) { return this.initializers = value; };
 FunctionDefinition.prototype.get$nativeBody = function() { return this.nativeBody; };
 FunctionDefinition.prototype.set$nativeBody = function(value) { return this.nativeBody = value; };
 FunctionDefinition.prototype.get$body = function() { return this.body; };
 FunctionDefinition.prototype.set$body = function(value) { return this.body = value; };
 FunctionDefinition.prototype.visit = function(visitor) {
-  return visitor.visitFunctionDefinition(this);
+  return visitor.visitFunctionDefinition$1(this);
 }
 FunctionDefinition.prototype.visit$1 = FunctionDefinition.prototype.visit;
 // ********** Code for ReturnStatement **************
 $inherits(ReturnStatement, Statement);
 function ReturnStatement(value, span) {
   this.value = value;
   Statement.call(this, span);
 }
 ReturnStatement.prototype.get$value = function() { return this.value; };
 ReturnStatement.prototype.set$value = function(value) { return this.value = value; };
 ReturnStatement.prototype.visit = function(visitor) {
-  return visitor.visitReturnStatement(this);
+  return visitor.visitReturnStatement$1(this);
 }
 ReturnStatement.prototype.visit$1 = ReturnStatement.prototype.visit;
 // ********** Code for ThrowStatement **************
 $inherits(ThrowStatement, Statement);
 function ThrowStatement(value, span) {
   this.value = value;
   Statement.call(this, span);
 }
 ThrowStatement.prototype.get$value = function() { return this.value; };
 ThrowStatement.prototype.set$value = function(value) { return this.value = value; };
 ThrowStatement.prototype.visit = function(visitor) {
-  return visitor.visitThrowStatement(this);
+  return visitor.visitThrowStatement$1(this);
 }
 ThrowStatement.prototype.visit$1 = ThrowStatement.prototype.visit;
 // ********** Code for AssertStatement **************
 $inherits(AssertStatement, Statement);
 function AssertStatement(test, span) {
   this.test = test;
   Statement.call(this, span);
 }
 AssertStatement.prototype.visit = function(visitor) {
-  return visitor.visitAssertStatement(this);
+  return visitor.visitAssertStatement$1(this);
 }
 AssertStatement.prototype.visit$1 = AssertStatement.prototype.visit;
 // ********** Code for BreakStatement **************
 $inherits(BreakStatement, Statement);
 function BreakStatement(label, span) {
   this.label = label;
   Statement.call(this, span);
 }
 BreakStatement.prototype.get$label = function() { return this.label; };
 BreakStatement.prototype.set$label = function(value) { return this.label = value; };
 BreakStatement.prototype.visit = function(visitor) {
-  return visitor.visitBreakStatement(this);
+  return visitor.visitBreakStatement$1(this);
 }
 BreakStatement.prototype.visit$1 = BreakStatement.prototype.visit;
 // ********** Code for ContinueStatement **************
 $inherits(ContinueStatement, Statement);
 function ContinueStatement(label, span) {
   this.label = label;
   Statement.call(this, span);
 }
 ContinueStatement.prototype.get$label = function() { return this.label; };
 ContinueStatement.prototype.set$label = function(value) { return this.label = value; };
 ContinueStatement.prototype.visit = function(visitor) {
-  return visitor.visitContinueStatement(this);
+  return visitor.visitContinueStatement$1(this);
 }
 ContinueStatement.prototype.visit$1 = ContinueStatement.prototype.visit;
 // ********** Code for IfStatement **************
 $inherits(IfStatement, Statement);
 function IfStatement(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.falseBranch = falseBranch;
   this.trueBranch = trueBranch;
   Statement.call(this, span);
 }
 IfStatement.prototype.visit = function(visitor) {
-  return visitor.visitIfStatement(this);
+  return visitor.visitIfStatement$1(this);
 }
 IfStatement.prototype.visit$1 = IfStatement.prototype.visit;
 // ********** Code for WhileStatement **************
 $inherits(WhileStatement, Statement);
 function WhileStatement(test, body, span) {
   this.body = body;
   this.test = test;
   Statement.call(this, span);
 }
 WhileStatement.prototype.get$body = function() { return this.body; };
 WhileStatement.prototype.set$body = function(value) { return this.body = value; };
 WhileStatement.prototype.visit = function(visitor) {
-  return visitor.visitWhileStatement(this);
+  return visitor.visitWhileStatement$1(this);
 }
 WhileStatement.prototype.visit$1 = WhileStatement.prototype.visit;
 // ********** Code for DoStatement **************
 $inherits(DoStatement, Statement);
 function DoStatement(body, test, span) {
   this.body = body;
   this.test = test;
   Statement.call(this, span);
 }
 DoStatement.prototype.get$body = function() { return this.body; };
 DoStatement.prototype.set$body = function(value) { return this.body = value; };
 DoStatement.prototype.visit = function(visitor) {
-  return visitor.visitDoStatement(this);
+  return visitor.visitDoStatement$1(this);
 }
 DoStatement.prototype.visit$1 = DoStatement.prototype.visit;
 // ********** Code for ForStatement **************
 $inherits(ForStatement, Statement);
 function ForStatement(init, test, step, body, span) {
   this.body = body;
   this.test = test;
   this.step = step;
   this.init = init;
   Statement.call(this, span);
 }
 ForStatement.prototype.get$body = function() { return this.body; };
 ForStatement.prototype.set$body = function(value) { return this.body = value; };
 ForStatement.prototype.visit = function(visitor) {
-  return visitor.visitForStatement(this);
+  return visitor.visitForStatement$1(this);
 }
 ForStatement.prototype.visit$1 = ForStatement.prototype.visit;
 // ********** Code for ForInStatement **************
 $inherits(ForInStatement, Statement);
 function ForInStatement(item, list, body, span) {
   this.body = body;
   this.item = item;
   this.list = list;
   Statement.call(this, span);
 }
 ForInStatement.prototype.get$body = function() { return this.body; };
 ForInStatement.prototype.set$body = function(value) { return this.body = value; };
 ForInStatement.prototype.visit = function(visitor) {
-  return visitor.visitForInStatement(this);
+  return visitor.visitForInStatement$1(this);
 }
 ForInStatement.prototype.visit$1 = ForInStatement.prototype.visit;
 // ********** Code for TryStatement **************
 $inherits(TryStatement, Statement);
 function TryStatement(body, catches, finallyBlock, span) {
   this.body = body;
   this.finallyBlock = finallyBlock;
   this.catches = catches;
   Statement.call(this, span);
 }
 TryStatement.prototype.get$body = function() { return this.body; };
 TryStatement.prototype.set$body = function(value) { return this.body = value; };
 TryStatement.prototype.visit = function(visitor) {
-  return visitor.visitTryStatement(this);
+  return visitor.visitTryStatement$1(this);
 }
 TryStatement.prototype.visit$1 = TryStatement.prototype.visit;
 // ********** Code for SwitchStatement **************
 $inherits(SwitchStatement, Statement);
 function SwitchStatement(test, cases, span) {
   this.test = test;
   this.cases = cases;
   Statement.call(this, span);
 }
 SwitchStatement.prototype.get$cases = function() { return this.cases; };
 SwitchStatement.prototype.set$cases = function(value) { return this.cases = value; };
 SwitchStatement.prototype.visit = function(visitor) {
-  return visitor.visitSwitchStatement(this);
+  return visitor.visitSwitchStatement$1(this);
 }
 SwitchStatement.prototype.visit$1 = SwitchStatement.prototype.visit;
 // ********** Code for BlockStatement **************
 $inherits(BlockStatement, Statement);
 function BlockStatement(body, span) {
   this.body = body;
   Statement.call(this, span);
 }
 BlockStatement.prototype.get$body = function() { return this.body; };
 BlockStatement.prototype.set$body = function(value) { return this.body = value; };
 BlockStatement.prototype.visit = function(visitor) {
-  return visitor.visitBlockStatement(this);
+  return visitor.visitBlockStatement$1(this);
 }
 BlockStatement.prototype.visit$1 = BlockStatement.prototype.visit;
 // ********** Code for LabeledStatement **************
 $inherits(LabeledStatement, Statement);
 function LabeledStatement(name, body, span) {
   this.body = body;
   this.name = name;
   Statement.call(this, span);
 }
 LabeledStatement.prototype.get$name = function() { return this.name; };
 LabeledStatement.prototype.set$name = function(value) { return this.name = value; };
 LabeledStatement.prototype.get$body = function() { return this.body; };
 LabeledStatement.prototype.set$body = function(value) { return this.body = value; };
 LabeledStatement.prototype.visit = function(visitor) {
-  return visitor.visitLabeledStatement(this);
+  return visitor.visitLabeledStatement$1(this);
 }
 LabeledStatement.prototype.visit$1 = LabeledStatement.prototype.visit;
 // ********** Code for ExpressionStatement **************
 $inherits(ExpressionStatement, Statement);
 function ExpressionStatement(body, span) {
   this.body = body;
   Statement.call(this, span);
 }
 ExpressionStatement.prototype.get$body = function() { return this.body; };
 ExpressionStatement.prototype.set$body = function(value) { return this.body = value; };
 ExpressionStatement.prototype.visit = function(visitor) {
-  return visitor.visitExpressionStatement(this);
+  return visitor.visitExpressionStatement$1(this);
 }
 ExpressionStatement.prototype.visit$1 = ExpressionStatement.prototype.visit;
 // ********** Code for EmptyStatement **************
 $inherits(EmptyStatement, Statement);
 function EmptyStatement(span) {
   Statement.call(this, span);
 }
 EmptyStatement.prototype.visit = function(visitor) {
-  return visitor.visitEmptyStatement(this);
+  return visitor.visitEmptyStatement$1(this);
 }
 EmptyStatement.prototype.visit$1 = EmptyStatement.prototype.visit;
 // ********** Code for DietStatement **************
 $inherits(DietStatement, Statement);
 function DietStatement(span) {
   Statement.call(this, span);
 }
 DietStatement.prototype.visit = function(visitor) {
-  return visitor.visitDietStatement(this);
+  return visitor.visitDietStatement$1(this);
 }
 DietStatement.prototype.visit$1 = DietStatement.prototype.visit;
 // ********** Code for LambdaExpression **************
 $inherits(LambdaExpression, Expression);
 function LambdaExpression(func, span) {
   this.func = func;
   Expression.call(this, span);
 }
 LambdaExpression.prototype.get$func = function() { return this.func; };
 LambdaExpression.prototype.set$func = function(value) { return this.func = value; };
 LambdaExpression.prototype.visit = function(visitor) {
-  return visitor.visitLambdaExpression(this);
+  return visitor.visitLambdaExpression$1(this);
 }
 LambdaExpression.prototype.visit$1 = LambdaExpression.prototype.visit;
 // ********** Code for CallExpression **************
 $inherits(CallExpression, Expression);
 function CallExpression(target, arguments, span) {
   this.target = target;
   this.arguments = arguments;
   Expression.call(this, span);
 }
 CallExpression.prototype.visit = function(visitor) {
   return visitor.visitCallExpression(this);
 }
 CallExpression.prototype.visit$1 = CallExpression.prototype.visit;
 // ********** Code for IndexExpression **************
 $inherits(IndexExpression, Expression);
 function IndexExpression(target, index, span) {
   this.target = target;
   this.index = index;
   Expression.call(this, span);
 }
 IndexExpression.prototype.visit = function(visitor) {
-  return visitor.visitIndexExpression(this);
+  return visitor.visitIndexExpression$1(this);
 }
 IndexExpression.prototype.visit$1 = IndexExpression.prototype.visit;
 // ********** Code for BinaryExpression **************
 $inherits(BinaryExpression, Expression);
 function BinaryExpression(op, x, y, span) {
   this.y = y;
   this.x = x;
   this.op = op;
   Expression.call(this, span);
 }
@@ skipping 46 matching lines @@
   this.isConst = isConst;
   Expression.call(this, span);
 }
 NewExpression.prototype.get$isConst = function() { return this.isConst; };
 NewExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 NewExpression.prototype.get$type = function() { return this.type; };
 NewExpression.prototype.set$type = function(value) { return this.type = value; };
 NewExpression.prototype.get$name = function() { return this.name; };
 NewExpression.prototype.set$name = function(value) { return this.name = value; };
 NewExpression.prototype.visit = function(visitor) {
-  return visitor.visitNewExpression(this);
+  return visitor.visitNewExpression$1(this);
 }
 NewExpression.prototype.visit$1 = NewExpression.prototype.visit;
 // ********** Code for ListExpression **************
 $inherits(ListExpression, Expression);
 function ListExpression(isConst, itemType, values, span) {
   this.itemType = itemType;
   this.isConst = isConst;
   this.values = values;
   Expression.call(this, span);
 }
 ListExpression.prototype.get$isConst = function() { return this.isConst; };
 ListExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 ListExpression.prototype.visit = function(visitor) {
   return visitor.visitListExpression(this);
 }
 ListExpression.prototype.visit$1 = ListExpression.prototype.visit;
 // ********** Code for MapExpression **************
 $inherits(MapExpression, Expression);
 function MapExpression(isConst, keyType, valueType, items, span) {
   this.keyType = keyType;
   this.valueType = valueType;
   this.items = items;
   this.isConst = isConst;
   Expression.call(this, span);
 }
 MapExpression.prototype.get$isConst = function() { return this.isConst; };
 MapExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 MapExpression.prototype.visit = function(visitor) {
-  return visitor.visitMapExpression(this);
+  return visitor.visitMapExpression$1(this);
 }
 MapExpression.prototype.visit$1 = MapExpression.prototype.visit;
 // ********** Code for ConditionalExpression **************
 $inherits(ConditionalExpression, Expression);
 function ConditionalExpression(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.falseBranch = falseBranch;
   this.trueBranch = trueBranch;
   Expression.call(this, span);
 }
@@ skipping 88 matching lines @@
 SuperExpression.prototype.visit$1 = SuperExpression.prototype.visit;
 // ********** Code for LiteralExpression **************
 $inherits(LiteralExpression, Expression);
 function LiteralExpression(value, span) {
   this.value = value;
   Expression.call(this, span);
 }
 LiteralExpression.prototype.get$value = function() { return this.value; };
 LiteralExpression.prototype.set$value = function(value) { return this.value = value; };
 LiteralExpression.prototype.visit = function(visitor) {
-  return visitor.visitLiteralExpression(this);
+  return visitor.visitLiteralExpression$1(this);
 }
 LiteralExpression.prototype.visit$1 = LiteralExpression.prototype.visit;
 // ********** Code for StringInterpExpression **************
 $inherits(StringInterpExpression, Expression);
 function StringInterpExpression(pieces, span) {
   this.pieces = pieces;
   Expression.call(this, span);
 }
 StringInterpExpression.prototype.visit = function(visitor) {
   return visitor.visitStringInterpExpression(this);
@@ skipping 169 matching lines @@
 function DeclaredIdentifier(type, name, span) {
   this.name = name;
   this.type = type;
   Expression.call(this, span);
 }
 DeclaredIdentifier.prototype.get$type = function() { return this.type; };
 DeclaredIdentifier.prototype.set$type = function(value) { return this.type = value; };
 DeclaredIdentifier.prototype.get$name = function() { return this.name; };
 DeclaredIdentifier.prototype.set$name = function(value) { return this.name = value; };
 DeclaredIdentifier.prototype.visit = function(visitor) {
-  return visitor.visitDeclaredIdentifier(this);
+  return visitor.visitDeclaredIdentifier$1(this);
 }
 DeclaredIdentifier.prototype.visit$1 = DeclaredIdentifier.prototype.visit;
 // ********** Code for Type **************
 $inherits(Type, Element);
 function Type(name) {
   this.isTested = false;
-  this._resolvedMembers = new HashMapImplementation();
+  this._foundMembers = new HashMapImplementation();
   this.isChecked = false;
   this.isWritten = false;
   this.varStubs = new HashMapImplementation();
   Element.call(this, name, null);
 }
 Type.prototype.get$typeCheckCode = function() { return this.typeCheckCode; };
 Type.prototype.set$typeCheckCode = function(value) { return this.typeCheckCode = value; };
 Type.prototype.get$varStubs = function() { return this.varStubs; };
 Type.prototype.set$varStubs = function(value) { return this.varStubs = value; };
 Type.prototype.markUsed = function() {
@@ skipping 125 matching lines @@
       var typeParam = params.next$0();
       var typeArg = args.next$0();
       if (typeParam.get$extendsType() != null && 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.get$length(); $$i++) {
-      var i = $$list.$index($$i);
+      var i = $$list[$$i];
       i._checkExtends$0();
     }
   }
 }
 Type.prototype._checkOverride = function(member) {
   var parentMember = this._getMemberInParents(member.name);
   if (parentMember != null) {
     if (!member.get$isPrivate() || $eq(member.get$library(), parentMember.get$library())) {
       member.override(parentMember);
     }
@@ skipping 18 matching lines @@
       return this.get$parent().getMember(memberName);
     }
     else {
       return null;
     }
   }
   else {
     if (this.get$interfaces() != null && this.get$interfaces().get$length() > (0)) {
       var $$list = this.get$interfaces();
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-        var i = $$list.$index($$i);
+        var i = $$list[$$i];
         var ret = i.getMember$1(memberName);
         if (ret != null) {
           return ret;
         }
       }
     }
     return $globals.world.objectType.getMember(memberName);
   }
 }
-Type.prototype.resolveMember = function(memberName) {
-  var ret = this._resolvedMembers.$index(memberName);
-  if (ret != null) return ret;
-  var member = this.getMember(memberName);
-  if (member == null) {
-    return null;
-  }
-  ret = new MemberSet(member, false);
-  this._resolvedMembers.$setindex(memberName, ret);
-  if (member.get$isStatic()) {
-    return ret;
-  }
-  else {
-    var $$list = this.get$subtypes();
-    for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
-      var t = $$i.next$0();
-      if (!this.get$isClass() && t.get$isClass()) {
-        var m = t.getMember$1(memberName);
-        if (m != null && ret.members.indexOf(m) == (-1)) {
-          ret.add(m);
-        }
-      }
-      else {
-        var m = t.get$members().$index(memberName);
-        if (m != null) ret.add(m);
-      }
-    }
-    return ret;
-  }
-}
 Type.prototype.ensureSubtypeOf = function(other, span, typeErrors) {
   if (!this.isSubtypeOf(other)) {
     var msg = ("type " + this.name + " is not a subtype of " + other.name);
     if (typeErrors) {
       $globals.world.error(msg, span);
     }
     else {
       $globals.world.warning(msg, span);
     }
   }
@@ skipping 128 matching lines @@
 }
 ParameterType.prototype.getCallMethod = function() {
   return this.extendsType.getCallMethod();
 }
 ParameterType.prototype.genMethod = function(method) {
   this.extendsType.genMethod(method);
 }
 ParameterType.prototype.isSubtypeOf = function(other) {
   return true;
 }
-ParameterType.prototype.resolveMember = function(memberName) {
-  return this.extendsType.resolveMember(memberName);
-}
 ParameterType.prototype.getConstructor = function(constructorName) {
   $globals.world.internalError("no constructors on type parameters yet");
 }
 ParameterType.prototype.getOrMakeConcreteType = function(typeArgs) {
   $globals.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) {
@@ skipping 26 matching lines @@
 NonNullableType.prototype.get$isBool = function() {
   return this.type.get$isBool();
 }
 NonNullableType.prototype.get$isUsed = function() {
   return false;
 }
 NonNullableType.prototype.isSubtypeOf = function(other) {
   return $eq(this, other) || $eq(this.type, other) || this.type.isSubtypeOf(other);
 }
 NonNullableType.prototype.resolveType = function(node, isRequired) {
-  return this.type.resolveType(node, isRequired);
+  return this.type.resolveType$2(node, isRequired);
 }
 NonNullableType.prototype.resolveTypeParams = function(inType) {
   return this.type.resolveTypeParams(inType);
 }
 NonNullableType.prototype.addDirectSubtype = function(subtype) {
-  this.type.addDirectSubtype(subtype);
+  this.type.addDirectSubtype$1(subtype);
 }
 NonNullableType.prototype.markUsed = function() {
   this.type.markUsed();
 }
 NonNullableType.prototype.genMethod = function(method) {
   this.type.genMethod(method);
 }
 NonNullableType.prototype.get$span = function() {
   return this.type.get$span();
 }
-NonNullableType.prototype.resolveMember = function(name) {
-  return this.type.resolveMember(name);
-}
 NonNullableType.prototype.getMember = function(name) {
   return this.type.getMember(name);
 }
 NonNullableType.prototype.getConstructor = function(name) {
   return this.type.getConstructor$1(name);
 }
 NonNullableType.prototype.getFactory = function(t, name) {
   return this.type.getFactory$2(t, name);
 }
 NonNullableType.prototype.getOrMakeConcreteType = function(typeArgs) {
@@ skipping 84 matching lines @@
 ConcreteType.prototype.get$isClass = function() {
   return this.genericType.isClass;
 }
 ConcreteType.prototype.get$library = function() {
   return this.genericType.library;
 }
 ConcreteType.prototype.get$span = function() {
   return this.genericType.get$span();
 }
 ConcreteType.prototype.get$hasTypeParams = function() {
-  return this.typeArguments.getValues$0().some$1((function (e) {
+  return this.typeArguments.getValues().some((function (e) {
     return (e instanceof ParameterType);
   })
   );
 }
 ConcreteType.prototype.get$isUsed = function() { return this.isUsed; };
 ConcreteType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
 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.get$length(); $$i++) {
-    var t = $$list.$index($$i);
+    var t = $$list[$$i];
     var newType = t.resolveTypeParams$1(inType);
     if ($ne(newType, t)) needsNewType = true;
     newTypeArgs.add$1(newType);
   }
   if (!needsNewType) return this;
   return this.genericType.getOrMakeConcreteType(newTypeArgs);
 }
 ConcreteType.prototype.getOrMakeConcreteType = function(typeArgs) {
   return this.genericType.getOrMakeConcreteType(typeArgs);
 }
 ConcreteType.prototype.get$parent = function() {
   if (this._parent == null && this.genericType.get$parent() != null) {
     this._parent = this.genericType.get$parent().resolveTypeParams(this);
   }
   return this._parent;
 }
 ConcreteType.prototype.get$interfaces = function() {
   if (this._interfaces == null && this.genericType.interfaces != null) {
     this._interfaces = [];
     var $$list = this.genericType.interfaces;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var i = $$list.$index($$i);
+      var i = $$list[$$i];
       this._interfaces.add(i.resolveTypeParams$1(this));
     }
   }
   return this._interfaces;
 }
 ConcreteType.prototype.get$subtypes = function() {
   if (this._subtypes == null) {
     this._subtypes = new HashSetImplementation();
     var $$list = this.genericType.get$subtypes();
     for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
@@ skipping 48 matching lines @@
     ret = new ConcreteMember(genericMember.get$name(), this, genericMember);
     this.factories.addFactory(this.name, constructorName, ret);
   }
   else {
     ret = new ConcreteMember(this.name, this, genericMember);
     this.constructors.$setindex(constructorName, ret);
   }
   return ret;
 }
 ConcreteType.prototype.getMember = function(memberName) {
-  var member = this.members.$index(memberName);
+  var member = this._foundMembers.$index(memberName);
+  if (member != null) return member;
+  member = this.members.$index(memberName);
   if (member != null) {
     this._checkOverride(member);
+    this._foundMembers.$setindex(memberName, member);
     return member;
   }
   var genericMember = this.genericType.members.$index(memberName);
   if (genericMember != null) {
     member = new ConcreteMember(genericMember.get$name(), this, genericMember);
     this.members.$setindex(memberName, member);
+    this._foundMembers.$setindex(memberName, member);
     return member;
   }
-  return this._getMemberInParents(memberName);
+  member = this._getMemberInParents(memberName);
+  this._foundMembers.$setindex(memberName, member);
+  return member;
 }
 ConcreteType.prototype.resolveType = function(node, isRequired) {
-  var ret = this.genericType.resolveType(node, isRequired);
+  var ret = this.genericType.resolveType$2(node, isRequired);
   return ret;
 }
 ConcreteType.prototype.addDirectSubtype = function(type) {
   this.genericType.addDirectSubtype(type);
 }
 ConcreteType.prototype.addDirectSubtype$1 = ConcreteType.prototype.addDirectSubtype;
 ConcreteType.prototype.getConstructor$1 = ConcreteType.prototype.getConstructor;
 ConcreteType.prototype.getFactory$2 = ConcreteType.prototype.getFactory;
 ConcreteType.prototype.getMember$1 = ConcreteType.prototype.getMember;
 ConcreteType.prototype.getOrMakeConcreteType$1 = ConcreteType.prototype.getOrMakeConcreteType;
@@ skipping 111 matching lines @@
 DefinedType.prototype.getAllMembers = function() {
   return HashMapImplementation.HashMapImplementation$from$factory(this.members);
 }
 DefinedType.prototype.markUsed = function() {
   if (this.isUsed) return;
   this.isUsed = true;
   this._checkExtends();
   if (this._lazyGenMethods != null) {
     var $$list = orderValuesByKeys(this._lazyGenMethods);
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var method = $$list.$index($$i);
+      var method = $$list[$$i];
       $globals.world.gen.genMethod(method);
     }
     this._lazyGenMethods = null;
   }
   if (this.get$parent() != null) this.get$parent().markUsed();
 }
 DefinedType.prototype.genMethod = function(method) {
   if (this.isUsed) {
     $globals.world.gen.genMethod(method);
   }
   else if (this.isClass) {
     if (this._lazyGenMethods == null) this._lazyGenMethods = new HashMapImplementation();
     this._lazyGenMethods.$setindex(method.name, method);
   }
 }
 DefinedType.prototype._resolveInterfaces = function(types) {
   if (types == null) return [];
   var interfaces = [];
   for (var $$i = 0;$$i < types.get$length(); $$i++) {
-    var type = types.$index($$i);
-    var resolvedInterface = this.resolveType(type, true);
+    var type = types[$$i];
+    var resolvedInterface = this.resolveType$2(type, true);
     if (resolvedInterface.get$isClosed() && !(this.library.get$isCore() || this.library.get$isCoreImpl())) {
       $globals.world.error(("can not implement \"" + resolvedInterface.get$name() + "\": ") + "only native implementation allowed", type.get$span());
     }
     resolvedInterface.addDirectSubtype$1(this);
     interfaces.add$1(resolvedInterface);
   }
   return interfaces;
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
   this.directSubtypes.add(type);
@@ skipping 34 matching lines @@
     if (ancestor == null) return false;
     if (ancestor == $this) return true;
     if (seen.contains$1(ancestor)) {
       return false;
     }
     seen.add$1(ancestor);
     if (ancestor.get$interfaces() != null) {
       var $$list = ancestor.get$interfaces();
       for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
         var parent = $$i.next$0();
-        if (_helper(parent)) return true;
+        if (_helper.call$1(parent)) return true;
       }
     }
     return false;
   }
   for (var i = (0);
    i < this.interfaces.get$length(); i++) {
-    if (_helper(this.interfaces.$index(i))) return i;
+    if (_helper.call$1(this.interfaces[i])) return i;
   }
   return (-1);
 }
 DefinedType.prototype.resolve = function() {
   if ((this.definition instanceof TypeDefinition)) {
     var typeDef = this.definition;
     if (this.isClass) {
       if (typeDef.extendsTypes != null && typeDef.extendsTypes.get$length() > (0)) {
         if (typeDef.extendsTypes.get$length() > (1)) {
-          $globals.world.error("more than one base class", typeDef.extendsTypes.$index((1)).get$span());
+          $globals.world.error("more than one base class", typeDef.extendsTypes[(1)].get$span());
         }
-        var extendsTypeRef = typeDef.extendsTypes.$index((0));
+        var extendsTypeRef = typeDef.extendsTypes[(0)];
         if ((extendsTypeRef instanceof GenericTypeReference)) {
           var g = extendsTypeRef;
-          this.set$parent(this.resolveType(g.baseType, true));
+          this.set$parent(this.resolveType$2(g.baseType, true));
         }
-        this.set$parent(this.resolveType(extendsTypeRef, true));
+        this.set$parent(this.resolveType$2(extendsTypeRef, true));
         if (!this.get$parent().get$isClass()) {
-          $globals.world.error("class may not extend an interface - use implements", typeDef.extendsTypes.$index((0)).get$span());
+          $globals.world.error("class may not extend an interface - use implements", typeDef.extendsTypes[(0)].get$span());
         }
-        this.get$parent().addDirectSubtype(this);
+        this.get$parent().addDirectSubtype$1(this);
         if (this._cycleInClassExtends()) {
           $globals.world.error(("class \"" + this.name + "\" has a cycle in its inheritance chain"), extendsTypeRef.get$span());
         }
       }
       else {
         if (!this.get$isObject()) {
           this.set$parent($globals.world.objectType);
-          this.get$parent().addDirectSubtype(this);
+          this.get$parent().addDirectSubtype$1(this);
         }
       }
       this.interfaces = this._resolveInterfaces(typeDef.implementsTypes);
       if (typeDef.defaultType != null) {
         $globals.world.error("default not allowed on classes", typeDef.defaultType.span);
       }
     }
     else {
       if (typeDef.implementsTypes != null && typeDef.implementsTypes.get$length() > (0)) {
-        $globals.world.error("implements not allowed on interfaces (use extends)", typeDef.implementsTypes.$index((0)).get$span());
+        $globals.world.error("implements not allowed on interfaces (use extends)", typeDef.implementsTypes[(0)].get$span());
       }
       this.interfaces = this._resolveInterfaces(typeDef.extendsTypes);
       var res = this._cycleInInterfaceExtends();
       if (res >= (0)) {
-        $globals.world.error(("interface \"" + this.name + "\" has a cycle in its inheritance chain"), typeDef.extendsTypes.$index(res).get$span());
+        $globals.world.error(("interface \"" + this.name + "\" has a cycle in its inheritance chain"), typeDef.extendsTypes[res].get$span());
       }
       if (typeDef.defaultType != null) {
-        this.defaultType = this.resolveType(typeDef.defaultType.baseType, true);
+        this.defaultType = this.resolveType$2(typeDef.defaultType.baseType, true);
         if (this.defaultType == null) {
           $globals.world.warning("unresolved default class", typeDef.defaultType.span);
         }
         else {
           this.defaultType._resolveTypeParams(typeDef.defaultType.typeParameters);
         }
       }
     }
   }
   else if ((this.definition instanceof FunctionTypeDefinition)) {
     this.interfaces = [$globals.world.functionType];
   }
   this._resolveTypeParams(this.typeParameters);
   if (this.get$isObject()) this._createNotEqualMember();
   $globals.world._addType(this);
-  var $$list = this.constructors.getValues$0();
+  var $$list = this.constructors.getValues();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var c = $$i.next$0();
     c.resolve$0();
   }
-  var $$list = this.members.getValues$0();
+  var $$list = this.members.getValues();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var m = $$i.next$0();
     m.resolve$0();
   }
   this.factories.forEach((function (f) {
     return f.resolve$0();
   })
   );
   if (this.get$isJsGlobalObject()) {
-    var $$list = this.members.getValues$0();
+    var $$list = this.members.getValues();
     for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
       var m = $$i.next$0();
       if (!m.get$isStatic()) $globals.world._addTopName(m);
     }
   }
 }
 DefinedType.prototype._resolveTypeParams = function(params) {
   if (params == null) return;
   for (var $$i = 0;$$i < params.get$length(); $$i++) {
-    var tp = params.$index($$i);
+    var tp = params[$$i];
     tp.set$enclosingElement(this);
     tp.resolve$0();
   }
 }
 DefinedType.prototype.addMethod = function(methodName, definition) {
   if (methodName == null) methodName = definition.name.name;
   var method = new MethodMember(methodName, this, definition);
   if (method.get$isConstructor()) {
     if (this.constructors.containsKey(method.get$constructorName())) {
       $globals.world.error(("duplicate constructor definition of " + method.get$name()), definition.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
   }
-  if (definition.modifiers != null && definition.modifiers.get$length() == (1) && $eq(definition.modifiers.$index((0)).get$kind(), (74))) {
+  if (definition.modifiers != null && definition.modifiers.get$length() == (1) && $eq(definition.modifiers[(0)].get$kind(), (74))) {
     if (this.factories.getFactory(method.get$constructorName(), method.get$name()) != null) {
       $globals.world.error(("duplicate factory definition of \"" + method.get$name() + "\""), definition.span);
       return;
     }
     this.factories.addFactory(method.get$constructorName(), method.get$name(), method);
     return;
   }
   if (methodName.startsWith("get:") || methodName.startsWith("set:")) {
     var propName = methodName.substring((4));
     var prop = this.members.$index(propName);
@@ skipping 21 matching lines @@
   }
   if (this.members.containsKey(methodName)) {
     $globals.world.error(("duplicate method definition of \"" + method.get$name() + "\""), definition.span);
     return;
   }
   this.members.$setindex(methodName, method);
 }
 DefinedType.prototype.addField = function(definition) {
   for (var i = (0);
    i < definition.names.get$length(); i++) {
-    var name = definition.names.$index(i).get$name();
+    var name = definition.names[i].get$name();
     if (this.members.containsKey(name)) {
       $globals.world.error(("duplicate field definition of \"" + name + "\""), definition.span);
       return;
     }
     var value = null;
     if (definition.values != null) {
-      value = definition.values.$index(i);
+      value = definition.values[i];
     }
     var field = new FieldMember(name, this, definition, value);
     this.members.$setindex(name, field);
     if (this.isNative) {
       field.set$isNative(true);
     }
   }
 }
 DefinedType.prototype.getFactory = function(type, constructorName) {
   var ret = this.factories.getFactory(type.name, constructorName);
@@ skipping 18 matching lines @@
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype._checkDefaultTypeParams = function() {
   function toList(list) {
     return (list != null ? list : const$0008);
   }
   var typeDef = this.definition;
   if (typeDef.defaultType.oldFactory) {
     return;
   }
-  var interfaceParams = toList(this.typeParameters);
-  var defaultParams = toList(typeDef.defaultType.typeParameters);
-  var classParams = toList(this.defaultType.typeParameters);
+  var interfaceParams = toList.call$1(this.typeParameters);
+  var defaultParams = toList.call$1(typeDef.defaultType.typeParameters);
+  var classParams = toList.call$1(this.defaultType.typeParameters);
   if ($ne(interfaceParams.get$length(), defaultParams.get$length()) || $ne(defaultParams.get$length(), classParams.get$length())) {
     $globals.world.error("\"default\" must have the same number of type parameters as the class and interface do", this.get$span(), typeDef.defaultType.span, this.defaultType.get$span());
     return;
   }
   for (var i = (0);
    i < interfaceParams.get$length(); i++) {
     var ip = interfaceParams.$index(i);
     var dp = defaultParams.$index(i);
     var cp = classParams.$index(i);
     dp.resolve$0();
@@ skipping 22 matching lines @@
     }
     var typeDef = this.definition;
     var c = new FunctionDefinition(null, null, typeDef.name, [], inits, native_, body, span);
     this.addMethod(null, c);
     this.constructors.$index("").resolve$0();
     return this.constructors.$index("");
   }
   return null;
 }
 DefinedType.prototype.getMember = function(memberName) {
-  var member = this.members.$index(memberName);
+  var member = this._foundMembers.$index(memberName);
+  if (member != null) return member;
+  member = this.members.$index(memberName);
   if (member != null) {
     this._checkOverride(member);
+    this._foundMembers.$setindex(memberName, member);
     return member;
   }
   if (this.get$isTop()) {
     var libType = this.library.findTypeByName(memberName);
     if (libType != null) {
-      return libType.get$typeMember();
+      member = libType.get$typeMember();
+      this._foundMembers.$setindex(memberName, member);
+      return member;
     }
   }
-  return this._getMemberInParents(memberName);
+  member = this._getMemberInParents(memberName);
+  this._foundMembers.$setindex(memberName, member);
+  return member;
 }
 DefinedType.prototype.resolveTypeParams = function(inType) {
   return this;
 }
 DefinedType.prototype.getOrMakeConcreteType = function(typeArgs) {
   var jsnames = [];
   var names = [];
   var typeMap = new HashMapImplementation();
   for (var i = (0);
    i < typeArgs.get$length(); i++) {
-    var paramName = this.typeParameters.$index(i).get$name();
-    typeMap.$setindex(paramName, typeArgs.$index(i));
-    names.add$1(typeArgs.$index(i).get$name());
-    jsnames.add$1(typeArgs.$index(i).get$jsname());
+    var paramName = this.typeParameters[i].get$name();
+    typeMap.$setindex(paramName, typeArgs[i]);
+    names.add$1(typeArgs[i].get$name());
+    jsnames.add$1(typeArgs[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.set$_jsname(jsname);
     this._concreteTypes.$setindex(key, ret);
   }
@@ skipping 62 matching lines @@
 }
 FixedCollection.prototype.every = function(f) {
   return Collections.every(this, f);
 }
 FixedCollection.prototype.some = function(f) {
   return Collections.some(this, f);
 }
 FixedCollection.prototype.isEmpty = function() {
   return this.length == (0);
 }
-FixedCollection.prototype.every$1 = function($0) {
-  return this.every(to$call$1($0));
-};
 FixedCollection.prototype.filter$1 = function($0) {
   return this.filter(to$call$1($0));
 };
 FixedCollection.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 FixedCollection.prototype.isEmpty$0 = FixedCollection.prototype.isEmpty;
 FixedCollection.prototype.iterator$0 = FixedCollection.prototype.iterator;
-FixedCollection.prototype.some$1 = function($0) {
-  return this.some(to$call$1($0));
-};
 // ********** Code for FixedCollection_Type **************
 $inherits(FixedCollection_Type, FixedCollection);
 function FixedCollection_Type(value, length) {
   this.value = value;
   this.length = length;
 }
 // ********** Code for FixedIterator **************
 function FixedIterator(value, length) {
   this.length = length;
   this._index = (0);
@@ skipping 106 matching lines @@
 CopyOnWriteMap.prototype.containsKey = function(key) {
   return this._lang_map.containsKey(key);
 }
 CopyOnWriteMap.prototype.containsKey$1 = CopyOnWriteMap.prototype.containsKey;
 CopyOnWriteMap.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 CopyOnWriteMap.prototype.getKeys$0 = CopyOnWriteMap.prototype.getKeys;
 CopyOnWriteMap.prototype.getValues$0 = CopyOnWriteMap.prototype.getValues;
 CopyOnWriteMap.prototype.isEmpty$0 = CopyOnWriteMap.prototype.isEmpty;
-CopyOnWriteMap.prototype.putIfAbsent$2 = function($0, $1) {
-  return this.putIfAbsent($0, to$call$0($1));
-};
 // ********** Code for CopyOnWriteMap_K$V **************
 $inherits(CopyOnWriteMap_K$V, CopyOnWriteMap);
 function CopyOnWriteMap_K$V() {}
 CopyOnWriteMap_K$V._wrap$ctor = function(_map) {
   this._lang_map = _map;
 }
 CopyOnWriteMap_K$V._wrap$ctor.prototype = CopyOnWriteMap_K$V.prototype;
 // ********** Code for CopyOnWriteMap_dart_core_String$VariableValue **************
 $inherits(CopyOnWriteMap_dart_core_String$VariableValue, CopyOnWriteMap);
 function CopyOnWriteMap_dart_core_String$VariableValue() {
@@ skipping 47 matching lines @@
 }
 Value.prototype.get$isFinal = function() {
   return false;
 }
 Value.prototype.get$needsTemp = function() {
   return true;
 }
 Value.prototype.get$staticType = function() {
   return this.get$type();
 }
+Value.comma = function(x, y) {
+  return new Value(y.get$type(), ("(" + x.get$code() + ", " + y.get$code() + ")"), null);
+}
 Value.union = function(x, y) {
   if (y == null || $eq(x, y)) return x;
   if (x == null) return y;
   var ret = x._tryUnion(y);
   if (ret != null) return ret;
   ret = y._tryUnion(x);
   if (ret != null) return ret;
   return new Value(Type.union(x.get$type(), y.get$type()), null, null);
 }
 Value.prototype._tryUnion = function(right) {
   return null;
 }
 Value.prototype.validateInitialized = function(span) {
 
 }
 Value.prototype.get_ = function(context, name, node) {
   var member = this._resolveMember(context, name, node, false);
   if (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) {
+Value.prototype.set_ = function(context, name, node, value, isDynamic, kind, returnKind) {
   var member = this._resolveMember(context, name, node, isDynamic);
   if (member != null) {
-    return member._set$5(context, node, this, value, isDynamic);
+    var thisValue = this;
+    var thisTmp = null;
+    var retTmp = null;
+    if (kind != (0)) {
+      thisTmp = context.getTemp(thisValue);
+      thisValue = context.assignTemp(thisTmp, thisValue);
+      var lhs = member._get$3(context, node, thisTmp);
+      if (returnKind == (3)) {
+        retTmp = context.forceTemp(lhs);
+        lhs = context.assignTemp(retTmp, lhs);
+      }
+      value = lhs.binop$4(kind, value, context, node);
+    }
+    if (returnKind == (2)) {
+      retTmp = context.forceTemp(value);
+      value = context.assignTemp(retTmp, value);
+    }
+    var ret = member._set$5(context, node, thisValue, value, isDynamic);
+    if (thisTmp != null && $ne(thisTmp, this)) context.freeTemp(thisTmp);
+    if (retTmp != null) {
+      context.freeTemp(retTmp);
+      return Value.comma(ret, retTmp);
+    }
+    else {
+      return ret;
+    }
   }
   else {
     return this.invokeNoSuchMethod(context, ("set:" + name), node, new Arguments(null, [value]));
   }
 }
+Value.prototype.setIndex = function(context, index, node, value, isDynamic, kind, returnKind) {
+  var member = this._resolveMember(context, ":setindex", node, isDynamic);
+  if (member != null) {
+    var thisValue = this;
+    var indexValue = index;
+    var thisTmp = null;
+    var indexTmp = null;
+    var retTmp = null;
+    if (returnKind == (2)) {
+      retTmp = context.forceTemp(value);
+    }
+    if (kind != (0)) {
+      thisTmp = context.getTemp(this);
+      indexTmp = context.getTemp(index);
+      thisValue = context.assignTemp(thisTmp, thisValue);
+      indexValue = context.assignTemp(indexTmp, indexValue);
+      if (returnKind == (3)) {
+        retTmp = context.forceTemp(value);
+      }
+      var lhs = thisTmp.invoke$4(context, ":index", node, new Arguments(null, [indexTmp]));
+      if (returnKind == (3)) {
+        lhs = context.assignTemp(retTmp, lhs);
+      }
+      value = lhs.binop$4(kind, value, context, node);
+    }
+    if (returnKind == (2)) {
+      value = context.assignTemp(retTmp, value);
+    }
+    var ret = member.invoke$5(context, node, thisValue, new Arguments(null, [indexValue, value]), isDynamic);
+    if (thisTmp != null && $ne(thisTmp, this)) context.freeTemp(thisTmp);
+    if (indexTmp != null && $ne(indexTmp, index)) context.freeTemp(indexTmp);
+    if (retTmp != null) {
+      context.freeTemp(retTmp);
+      return Value.comma(ret, retTmp);
+    }
+    else {
+      return ret;
+    }
+  }
+  else {
+    return this.invokeNoSuchMethod(context, ":index", node, new Arguments(null, [index, value]));
+  }
+}
 Value.prototype.unop = function(kind, context, node) {
   switch (kind) {
     case (19):
 
       var newVal = this.convertTo(context, $globals.world.nonNullBool, false);
       return new Value(newVal.get$type(), ("!" + newVal.get$code()), node.get$span());
 
     case (42):
 
       $globals.world.error("no unary add operator in dart", node.get$span());
@@ skipping 48 matching lines @@
   }
 }
 Value.prototype.canInvoke = function(context, name, args) {
   if (this.get$type().get$isVarOrFunction() && name == ":call") {
     return true;
   }
   var member = this._resolveMember(context, name, null, true);
   return member != null && member.canInvoke$2(context, args);
 }
 Value.prototype._hasOverriddenNoSuchMethod = function() {
-  if (this.get$isSuper()) {
-    var m = this.get$staticType().getMember("noSuchMethod");
-    return m != null && !m.get$declaringType().get$isObject();
+  var m = this.get$type().getMember("noSuchMethod");
+  return m != null && !m.get$declaringType().get$isObject();
+}
+Value.prototype.get$isPreciseType = function() {
+  return this.get$isSuper() || this.get$isType();
+}
+Value.prototype._missingMemberError = function(context, name, isDynamic, node) {
+  var onStaticType = false;
+  if ($ne(this.get$type(), this.get$staticType())) {
+    onStaticType = this.get$staticType().getMember(name) != null;
+  }
+  if (!onStaticType && !isDynamic && !this._isVarOrParameterType(this.get$staticType()) && !this._hasOverriddenNoSuchMethod()) {
+    var typeName = this.get$staticType().name;
+    if (typeName == null) typeName = this.get$staticType().get$library().name;
+    var message = ("can not resolve \"" + name + "\" on \"" + typeName + "\"");
+    if (this.get$isType()) {
+      $globals.world.error(message, node.span);
+    }
+    else {
+      $globals.world.warning(message, node.span);
+    }
+  }
+}
+Value.prototype._tryResolveMember = function(context, name, isDynamic, node) {
+  var member = this.get$type().getMember(name);
+  if (member == null) {
+    this._missingMemberError(context, name, isDynamic, node);
+    return null;
   }
   else {
-    var m = this.get$staticType().resolveMember("noSuchMethod");
-    return m != null && m.get$members().get$length() > (1);
+    if (this.get$isType() && !member.get$isStatic()) {
+      if (!isDynamic) {
+        $globals.world.error("can not refer to instance member as static", node.span);
+      }
+      return null;
+    }
   }
-}
-Value.prototype._tryResolveMember = function(context, resolvetype, name) {
-  if (this.get$isSuper()) {
-    return resolvetype.getMember(name);
+  if (this.get$isPreciseType() || member.get$isStatic()) {
+    return member.get$preciseMemberSet();
   }
   else {
-    return resolvetype.resolveMember(name);
+    return member.get$potentialMemberSet();
   }
 }
 Value.prototype._isVarOrParameterType = function(t) {
   return t.get$isVar() || (t instanceof ParameterType);
 }
 Value.prototype._shouldBindDynamically = function() {
   return this._isVarOrParameterType(this.get$type()) || $globals.options.forceDynamic && !this.get$isConst();
 }
 Value.prototype._resolveMember = function(context, name, node, isDynamic) {
-  var member;
+  var member = null;
   if (!this._shouldBindDynamically()) {
-    member = this._tryResolveMember(context, this.get$type(), name);
-    if (member == null && $ne(this.get$type(), this.get$staticType())) {
-      member = this._tryResolveMember(context, this.get$staticType(), name);
-    }
-    if (member != null && this.get$isType() && !member.get$isStatic()) {
-      if (!isDynamic) {
-        $globals.world.error("can not refer to instance member as static", node.span);
-      }
-      return null;
-    }
-    if (member == null && !isDynamic && !this._isVarOrParameterType(this.get$staticType()) && !this._hasOverriddenNoSuchMethod()) {
-      var typeName = this.get$staticType().name;
-      if (typeName == null) typeName = this.get$staticType().get$library().name;
-      var message = ("can not resolve \"" + name + "\" on \"" + typeName + "\"");
-      if (this.get$isType()) {
-        $globals.world.error(message, node.span);
-      }
-      else {
-        $globals.world.warning(message, node.span);
-      }
-    }
+    member = this._tryResolveMember(context, name, isDynamic, node);
   }
   if (member == null && !this.get$isSuper() && !this.get$isType()) {
     member = context.findMembers(name);
     if (member == null && !isDynamic) {
       var where = "the world";
       if (name.startsWith("_")) {
         where = ("library \"" + context.get$library().name + "\"");
       }
       $globals.world.warning(("" + name + " is not defined anywhere in " + where + "."), node.span);
     }
@@ skipping 82 matching lines @@
       $globals.world.gen.corejs.useThrow = true;
       return ("$throw(" + result.get$code() + ")");
     })
     );
   }
   if (toType.get$isNum()) toType = $globals.world.numType;
   var check;
   if (toType.get$isVoid()) {
     check = ("$assert_void(" + this.get$code() + ")");
     if (toType.typeCheckCode == null) {
-      toType.typeCheckCode = ("function $assert_void(x) {\n  if (x == null) return null;\n  " + throwTypeError("x") + "\n}");
+      toType.typeCheckCode = ("function $assert_void(x) {\n  if (x == null) return null;\n  " + throwTypeError.call$1("x") + "\n}");
     }
   }
   else if ($eq(toType, $globals.world.nonNullBool)) {
     $globals.world.gen.corejs.useNotNullBool = true;
     check = ("$notnull_bool(" + this.get$code() + ")");
   }
   else if (toType.get$library().get$isCore() && toType.get$typeofName() != null) {
     check = ("$assert_" + toType.name + "(" + this.get$code() + ")");
     if (toType.typeCheckCode == null) {
-      toType.typeCheckCode = ("function $assert_" + toType.name + "(x) {\n  if (x == null || typeof(x) == \"" + toType.get$typeofName() + "\") return x;\n  " + throwTypeError("x") + "\n}");
+      toType.typeCheckCode = ("function $assert_" + toType.name + "(x) {\n  if (x == null || typeof(x) == \"" + toType.get$typeofName() + "\") return x;\n  " + throwTypeError.call$1("x") + "\n}");
     }
   }
   else {
     toType.isChecked = true;
     var checkName = "assert$" + toType.get$jsname();
     var temp = context.getTemp(this);
     check = ("(" + context.assignTemp(temp, this).get$code() + " == null ? null :");
     check = check + (" " + temp.get$code() + "." + checkName + "())");
     if ($ne(this, temp)) context.freeTemp(temp);
-    $globals.world.objectType.varStubs.putIfAbsent$2(checkName, (function () {
-      return new VarMethodStub(checkName, null, Arguments.get$EMPTY(), throwTypeError("this"));
+    $globals.world.objectType.varStubs.putIfAbsent(checkName, (function () {
+      return new VarMethodStub(checkName, null, Arguments.get$EMPTY(), throwTypeError.call$1("this"));
     })
     );
   }
   context.counters.typeAsserts++;
   return new Value(toType, check, this.span);
 }
 Value.prototype.instanceOf = function(context, toType, span, isTrue, forceCheck) {
   if (toType.get$isVar()) {
     $globals.world.error("can not resolve type", span);
   }
@@ skipping 35 matching lines @@
     if (!$globals.world.objectType.varStubs.containsKey(checkName)) {
       $globals.world.objectType.varStubs.$setindex(checkName, new VarMethodStub(checkName, null, Arguments.get$EMPTY(), "return false"));
     }
   }
   return new Value($globals.world.nonNullBool, testCode, span);
 }
 Value.prototype.convertWarning = function(toType) {
   $globals.world.warning(("type \"" + this.get$type().name + "\" is not assignable to \"" + toType.name + "\""), this.span);
 }
 Value.prototype.invokeNoSuchMethod = function(context, name, node, args) {
+  if (this.get$isType()) {
+    $globals.world.error(("member lookup failed for \"" + name + "\""), node.span);
+  }
   var pos = "";
   if (args != null) {
     var argsCode = [];
     for (var i = (0);
      i < args.get$length(); i++) {
-      argsCode.add$1(args.values.$index(i).get$code());
+      argsCode.add$1(args.values[i].get$code());
     }
     pos = Strings.join(argsCode, ", ");
   }
   var noSuchArgs = [new Value($globals.world.stringType, ("\"" + name + "\""), node.span), new Value($globals.world.listType, ("[" + pos + "]"), node.span)];
-  return this._resolveMember(context, "noSuchMethod", node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs));
+  return this._resolveMember(context, "noSuchMethod", node, false).invoke(context, node, this, new Arguments(null, noSuchArgs), false);
 }
 Value.fromBool = function(value, span) {
   return new BoolValue(value, true, span);
 }
 Value.fromInt = function(value, span) {
   return new IntValue(value, true, span);
 }
 Value.fromDouble = function(value, span) {
   return new DoubleValue(value, true, span);
 }
@@ skipping 14 matching lines @@
 Value.prototype.instanceOf$4 = function($0, $1, $2, $3) {
   return this.instanceOf($0, $1, $2, $3, false);
 };
 Value.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 Value.prototype.invoke$4$isDynamic = Value.prototype.invoke;
 Value.prototype.invoke$5 = Value.prototype.invoke;
 Value.prototype.invokeNoSuchMethod$4 = Value.prototype.invokeNoSuchMethod;
 Value.prototype.needsConversion$1 = Value.prototype.needsConversion;
-Value.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, false);
+Value.prototype.setIndex$4$kind$returnKind = function($0, $1, $2, $3, kind, returnKind) {
+  return this.setIndex($0, $1, $2, $3, false, kind, returnKind);
+};
+Value.prototype.set_$4$kind$returnKind = function($0, $1, $2, $3, kind, returnKind) {
+  return this.set_($0, $1, $2, $3, false, kind, returnKind);
 };
 Value.prototype.unop$3 = Value.prototype.unop;
 // ********** Code for EvaluatedValue **************
 $inherits(EvaluatedValue, Value);
 function EvaluatedValue(isConst, type, span) {
   this.isConst = isConst;
   Value.call(this, type, "@@@", span);
 }
 EvaluatedValue.prototype.get$isConst = function() { return this.isConst; };
 EvaluatedValue.prototype.get$code = function() {
   $globals.world.internalError("Should not be getting code from raw EvaluatedValue", this.span);
 }
 EvaluatedValue.prototype.get$needsTemp = function() {
   return false;
 }
 EvaluatedValue.prototype.hashCode = function() {
   return this.get$code().hashCode();
 }
 EvaluatedValue.prototype.$eq = function(other) {
-  return (other instanceof EvaluatedValue) && $eq(other.get$type(), this.type) && $eq(other.get$code(), this.get$code());
+  return (other instanceof EvaluatedValue) && $eq(other.get$type(), this.get$type()) && $eq(other.get$code(), this.get$code());
 }
 EvaluatedValue.prototype.hashCode$0 = EvaluatedValue.prototype.hashCode;
 // ********** Code for NullValue **************
 $inherits(NullValue, EvaluatedValue);
 function NullValue(isConst, span) {
   EvaluatedValue.call(this, isConst, $globals.world.varType, span);
 }
 NullValue.prototype.get$actualValue = function() {
   return null;
 }
@@ skipping 126 matching lines @@
       case (39):
 
         return new IntValue(x << y, c, s);
 
       case (40):
 
         return new IntValue(x >> y, c, s);
 
       case (42):
 
-        return new IntValue(x + y, c, s);
+        return new IntValue($add(x, y), c, s);
 
       case (43):
 
         return new IntValue(x - y, c, s);
 
       case (44):
 
         return new IntValue(x * y, c, s);
 
       case (45):
@@ skipping 35 matching lines @@
 
         return new BoolValue(x == y, c, s);
 
       case (51):
       case (49):
 
         return new BoolValue(x != y, c, s);
 
       case (42):
 
-        return new DoubleValue(x + y, c, s);
+        return new DoubleValue($add(x, y), c, s);
 
       case (43):
 
         return new DoubleValue(x - y, c, s);
 
       case (44):
 
         return new DoubleValue(x * y, c, s);
 
       case (45):
@@ skipping 65 matching lines @@
 
         return new BoolValue(x == y, c, s);
 
       case (51):
       case (49):
 
         return new BoolValue(x != y, c, s);
 
       case (42):
 
-        return new DoubleValue(x + y, c, s);
+        return new DoubleValue($add(x, y), c, s);
 
       case (43):
 
         return new DoubleValue(x - y, c, s);
 
       case (44):
 
         return new DoubleValue(x * y, c, s);
 
       case (45):
@@ skipping 35 matching lines @@
 
         return new BoolValue(x == y, c, s);
 
       case (51):
       case (49):
 
         return new BoolValue(x != y, c, s);
 
       case (42):
 
-        return new DoubleValue(x + y, c, s);
+        return new DoubleValue($add(x, y), c, s);
 
       case (43):
 
         return new DoubleValue(x - y, c, s);
 
       case (44):
 
         return new DoubleValue(x * y, c, s);
 
       case (45):
@@ skipping 144 matching lines @@
 function ListValue(values, isConst, type, span) {
   this.values = values;
   EvaluatedValue.call(this, isConst, type, span);
 }
 ListValue.prototype.get$code = function() {
   var buf = new StringBufferImpl("");
   buf.add$1("[");
   for (var i = (0);
    i < this.values.get$length(); i = $add(i, (1))) {
     if (i > (0)) buf.add$1(", ");
-    buf.add$1(this.values.$index(i).get$code());
+    buf.add$1(this.values[i].get$code());
   }
   buf.add$1("]");
   var listCode = buf.toString$0();
   if (!this.isConst) return listCode;
   var v = new Value($globals.world.listType, listCode, this.span);
   var immutableListCtor = $globals.world.immutableListType.getConstructor("from");
   var result = immutableListCtor.invoke$4(null, null, new TypeValue(v.get$type(), this.span), new Arguments(null, [v]));
   return result.get$code();
 }
 ListValue.prototype.binop = function(kind, other, context, node) {
   if (!(other instanceof ListValue)) return Value.prototype.binop.call(this, kind, other, context, node);
   switch (kind) {
     case (50):
 
-      return new BoolValue($eq(this.type, other.get$type()) && this.get$code() == other.get$code(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue($eq(this.get$type(), other.get$type()) && this.get$code() == other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
     case (51):
 
-      return new BoolValue($ne(this.type, other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue($ne(this.get$type(), other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 ListValue.prototype.getGlobalValue = function() {
   return $globals.world.gen.globalForConst(this, this.values);
 }
 ListValue.prototype.binop$4 = ListValue.prototype.binop;
 ListValue.prototype.getGlobalValue$0 = ListValue.prototype.getGlobalValue;
 // ********** Code for MapValue **************
@@ skipping 10 matching lines @@
   return value.get$code();
 }
 MapValue.prototype.getGlobalValue = function() {
   return $globals.world.gen.globalForConst(this, this.values);
 }
 MapValue.prototype.binop = function(kind, other, context, node) {
   if (!(other instanceof MapValue)) return Value.prototype.binop.call(this, kind, other, context, node);
   switch (kind) {
     case (50):
 
-      return new BoolValue($eq(this.type, other.get$type()) && this.get$code() == other.get$code(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue($eq(this.get$type(), other.get$type()) && this.get$code() == other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
     case (51):
 
-      return new BoolValue($ne(this.type, other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue($ne(this.get$type(), other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 MapValue.prototype.binop$4 = MapValue.prototype.binop;
 MapValue.prototype.getGlobalValue$0 = MapValue.prototype.getGlobalValue;
 // ********** Code for ObjectValue **************
 $inherits(ObjectValue, EvaluatedValue);
 function ObjectValue(isConst, type, span) {
   this.seenNativeInitializer = false;
   this.fields = new HashMapImplementation();
   EvaluatedValue.call(this, isConst, type, span);
 }
 ObjectValue.prototype.get$fields = function() { return this.fields; };
 ObjectValue.prototype.get$seenNativeInitializer = function() { return this.seenNativeInitializer; };
 ObjectValue.prototype.set$seenNativeInitializer = function(value) { return this.seenNativeInitializer = value; };
 ObjectValue.prototype.get$code = function() {
   if (this._code == null) this.validateInitialized(null);
   return this._code;
 }
 ObjectValue.prototype.initFields = function() {
-  var allMembers = $globals.world.gen._orderValues(this.type.getAllMembers());
+  var allMembers = $globals.world.gen._orderValues(this.get$type().getAllMembers());
   for (var $$i = allMembers.iterator$0(); $$i.hasNext$0(); ) {
     var f = $$i.next$0();
     if (f.get$isField() && !f.get$isStatic() && f.get$declaringType().get$isClass()) {
       this.fields.$setindex(f, f.computeValue$0());
     }
   }
 }
 ObjectValue.prototype.setField = function(field, value, duringInit) {
   if (value.get$isConst() && (value instanceof VariableValue)) {
     value = value.get$dynamic().get$value();
@@ skipping 13 matching lines @@
       $globals.world.error("reassignment of field not allowed", value.span, field.get$span());
     }
     else {
       this.fields.$setindex(field, value);
     }
   }
 }
 ObjectValue.prototype.validateInitialized = function(span) {
   var buf = new StringBufferImpl("");
   buf.add$1("Object.create(");
-  buf.add$1(("" + this.type.get$jsname() + ".prototype, "));
+  buf.add$1(("" + this.get$type().get$jsname() + ".prototype, "));
   buf.add$1("{");
-  var $$list = this.fields.getKeys$0();
+  var $$list = this.fields.getKeys();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var field = $$i.next$0();
     buf.add$1(field.get$name());
     buf.add$1(": ");
     buf.add$1("{\"value\": ");
     if (this.fields.$index(field) == null) {
       $globals.world.error(("Required field \"" + field.get$name() + "\" was not initialized"), span, field.get$span());
       buf.add$1("null");
     }
     else {
       buf.add$1(this.fields.$index(field).get$code());
     }
     buf.add$1(", writeable: false}, ");
   }
   buf.add$1("})");
   this._code = buf.toString$0();
 }
 ObjectValue.prototype.binop = function(kind, other, context, node) {
   if (!(other instanceof ObjectValue)) return Value.prototype.binop.call(this, kind, other, context, node);
   switch (kind) {
     case (50):
     case (48):
 
-      return new BoolValue($eq(this.type, other.get$type()) && this.get$code() == other.get$code(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue($eq(this.get$type(), other.get$type()) && this.get$code() == other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
     case (51):
     case (49):
 
-      return new BoolValue($ne(this.type, other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue($ne(this.get$type(), other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 ObjectValue.prototype.binop$4 = ObjectValue.prototype.binop;
 ObjectValue.prototype.initFields$0 = ObjectValue.prototype.initFields;
 // ********** Code for GlobalValue **************
 $inherits(GlobalValue, Value);
 function GlobalValue(type, code, isConst, field, name, exp, span, deps) {
   this.exp = exp;
   this.field = field;
   this.name = name;
   this.dependencies = [];
   this.isConst = isConst;
   Value.call(this, type, code, span);
   for (var $$i = 0;$$i < deps.get$length(); $$i++) {
-    var dep = deps.$index($$i);
+    var dep = deps[$$i];
     if ((dep instanceof GlobalValue)) {
       this.dependencies.add(dep);
       this.dependencies.addAll(dep.get$dependencies());
     }
   }
 }
 GlobalValue.prototype.get$field = function() { return this.field; };
 GlobalValue.prototype.get$name = function() { return this.name; };
 GlobalValue.prototype.get$exp = function() { return this.exp; };
 GlobalValue.prototype.get$isConst = function() { return this.isConst; };
@@ skipping 45 matching lines @@
 BareValue.prototype.get$needsTemp = function() {
   return false;
 }
 BareValue.prototype._shouldBindDynamically = function() {
   return false;
 }
 BareValue.prototype.get$code = function() {
   return this._code;
 }
 BareValue.prototype._ensureCode = function() {
-  if (this._code == null) this._code = this.isType ? this.type.get$jsname() : this.home._makeThisCode();
+  if (this._code == null) this._code = this.isType ? this.get$type().get$jsname() : this.home._makeThisCode();
 }
-BareValue.prototype._tryResolveMember = function(context, resolveType, name) {
-  var member = resolveType.resolveMember(name);
-  if (member != null) {
-    if ($globals.options.forceDynamic && !member.get$isStatic()) {
-      member = context.findMembers(name);
+BareValue.prototype._tryResolveMember = function(context, name, isDynamic, node) {
+  var member = this.get$type().getMember(name);
+  if (member == null || $ne(member.get$declaringType(), this.get$type())) {
+    var libMember = this.home.get$library().lookup(name, this.span);
+    if (libMember != null) {
+      return libMember.get$preciseMemberSet();
     }
-    this._ensureCode();
-    return member;
-  }
-  member = this.home.get$library().lookup(name, this.span);
-  if (member != null) {
-    return member;
   }
   this._ensureCode();
-  return null;
+  return Value.prototype._tryResolveMember.call(this, context, name, isDynamic, node);
 }
 // ********** Code for SuperValue **************
 $inherits(SuperValue, Value);
 function SuperValue(parentType, span) {
   Value.call(this, parentType, "this", span);
 }
 SuperValue.prototype.get$needsTemp = function() {
   return false;
 }
 SuperValue.prototype.get$isSuper = function() {
@@ skipping 85 matching lines @@
 VariableValue.prototype.get$type = function() {
   return this.value != null ? this.value.get$type() : this.get$staticType();
 }
 VariableValue.prototype.get$staticType = function() {
   return this.type;
 }
 VariableValue.prototype.get$isConst = function() {
   return this.value != null ? this.value.get$isConst() : false;
 }
 VariableValue.prototype.replaceValue = function(v) {
-  return new VariableValue(this.get$staticType(), this.code, this.span, this.isFinal, v);
+  return new VariableValue(this.get$staticType(), this.get$code(), this.span, this.isFinal, v);
 }
 VariableValue.prototype.unop = function(kind, context, node) {
   if (this.value != null) {
     return this.replaceValue(this.value.unop(kind, context, node));
   }
   return Value.prototype.unop.call(this, kind, context, node);
 }
 VariableValue.prototype.binop = function(kind, other, context, node) {
   if (this.value != null) {
     return this.replaceValue(this.value.binop(kind, VariableValue._unwrap(other), context, node));
@@ skipping 12 matching lines @@
   if (this._location != null) {
     return ("CompilerException: " + this._location.toMessageString(this._lang_message));
   }
   else {
     return ("CompilerException: " + this._lang_message);
   }
 }
 CompilerException.prototype.toString$0 = CompilerException.prototype.toString;
 // ********** Code for CounterLog **************
 function CounterLog() {
+  this.msetN = (0);
   this.objectProtoMembers = (0);
   this.dynamicMethodCalls = (0);
   this.typeAsserts = (0);
+  this.invokeCalls = (0);
 }
 CounterLog.prototype.info = function() {
   $globals.world.info(("Dynamically typed method calls: " + this.dynamicMethodCalls));
   $globals.world.info(("Generated type assertions: " + this.typeAsserts));
   $globals.world.info(("Members on Object.prototype: " + this.objectProtoMembers));
+  $globals.world.info(("Invoke calls: " + this.invokeCalls));
+  $globals.world.info(("msetN calls: " + this.msetN));
 }
 CounterLog.prototype.add = function(other) {
-  this.dynamicMethodCalls += other.dynamicMethodCalls;
-  this.typeAsserts += other.typeAsserts;
-  this.objectProtoMembers += other.objectProtoMembers;
+  this.dynamicMethodCalls = $add(this.dynamicMethodCalls, other.dynamicMethodCalls);
+  this.typeAsserts = $add(this.typeAsserts, other.typeAsserts);
+  this.objectProtoMembers = $add(this.objectProtoMembers, other.objectProtoMembers);
+  this.invokeCalls = $add(this.invokeCalls, other.invokeCalls);
+  this.msetN = $add(this.msetN, other.msetN);
 }
 CounterLog.prototype.add$1 = CounterLog.prototype.add;
 // ********** Code for World **************
 function World(files) {
   this.files = files;
   this._members = new HashMapImplementation();
   this._topNames = new HashMapImplementation();
   this.warnings = (0);
   this.seenFatal = false;
   this.libraries = new HashMapImplementation();
@@ skipping 142 matching lines @@
   this.printStatus();
   return !this.get$hasErrors();
 }
 World.prototype.runLeg = function() {
   var $this = this; // closure support
   if (!$globals.options.enableLeg) return false;
   if ($globals.legCompile == null) {
     this.fatal("requested leg enabled, but no leg compiler available");
   }
   var res = this.withTiming("try leg compile", (function () {
-    return $globals.legCompile($this);
+    return $globals.legCompile.call$1($this);
   })
   );
   if (!res && $globals.options.legOnly) {
     this.fatal(("Leg could not compile " + $globals.options.dartScript));
     return true;
   }
   return res;
 }
 World.prototype.runCompilationPhases = function() {
   var $this = this; // closure support
@@ skipping 14 matching lines @@
   if (this.legCode != null) {
     return this.legCode;
   }
   else {
     return this.frogCode;
   }
 }
 World.prototype.readFile = function(filename) {
   try {
     var sourceFile = this.reader.readFile(filename);
-    this.dartBytesRead = this.dartBytesRead + sourceFile.get$text().get$length();
+    this.dartBytesRead = $add(this.dartBytesRead, sourceFile.get$text().get$length());
     return sourceFile;
   } catch (e) {
     e = _toDartException(e);
     this.warning(("Error reading file: " + filename));
     return new SourceFile(filename, "");
   }
 }
 World.prototype.getOrAddLibrary = function(filename) {
   var library = this.libraries.$index(filename);
   if (library == null) {
@@ skipping 23 matching lines @@
     }
   }
 }
 World.prototype.processDartScript = function(script) {
   if (script == null) script = $globals.options.dartScript;
   var library = this.getOrAddLibrary(script);
   this.process();
   return library;
 }
 World.prototype.resolveAll = function() {
-  var $$list = this.libraries.getValues$0();
+  var $$list = this.libraries.getValues();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var lib = $$i.next$0();
     lib.resolve$0();
   }
-  var $$list = this.libraries.getValues$0();
+  var $$list = this.libraries.getValues();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var lib = $$i.next$0();
     lib.postResolveChecks$0();
   }
 }
 World.prototype.get$resolveAll = function() {
   return this.resolveAll.bind(this);
 }
 World.prototype.findMainMethod = function(lib) {
-  var mainMembers = lib.topType.resolveMember("main");
-  var main = null;
-  if (mainMembers == null || $eq(mainMembers.get$members().get$length(), (0))) {
+  var main = lib.lookup("main", lib.get$span());
+  if (main == null) {
     this.fatal("no main method specified");
   }
-  else if (mainMembers.get$members().get$length() > (1)) {
-    var $$list = mainMembers.get$members();
-    for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
-      var m = $$i.next$0();
-      main = m;
-      this.error("more than one main member (using last?)", main.get$span());
-    }
-  }
-  else {
-    main = mainMembers.get$members().$index((0));
-  }
   return main;
 }
 World.prototype.generateCode = function(lib) {
   this.gen = new WorldGenerator(this.findMainMethod(lib), new CodeWriter());
   this.gen.run();
   this.frogCode = this.gen.writer.get$text();
   this.jsBytesWritten = this.frogCode.length;
   this.gen = null;
 }
 World.prototype._message = function(color, prefix, message, span, span1, span2, throwing) {
@@ skipping 48 matching lines @@
 }
 World.prototype.info = function(message, span, span1, span2) {
   if ($globals.options.showInfo) {
     this._message($globals._GREEN_COLOR, "info: ", message, span, span1, span2, false);
   }
 }
 World.prototype.withoutForceDynamic = function(fn) {
   var oldForceDynamic = $globals.options.forceDynamic;
   $globals.options.forceDynamic = false;
   try {
-    return fn();
+    return fn.call$0();
   } finally {
     $globals.options.forceDynamic = oldForceDynamic;
   }
 }
 World.prototype.get$hasErrors = function() {
   return this.errors > (0);
 }
 World.prototype.printStatus = function() {
   this.counters.info();
   this.info(("compiled " + this.dartBytesRead + " bytes Dart -> " + this.jsBytesWritten + " bytes JS"));
   if (this.get$hasErrors()) {
     print(("compilation failed with " + this.errors + " errors"));
   }
   else {
     if (this.warnings > (0)) {
       this.info(("compilation completed successfully with " + this.warnings + " warnings"));
     }
     else {
       this.info("compilation completed sucessfully");
     }
   }
 }
 World.prototype.withTiming = function(name, f) {
   var sw = new StopwatchImplementation();
   sw.start$0();
-  var result = f();
+  var result = f.call$0();
   sw.stop$0();
   this.info(("" + name + " in " + sw.elapsedInMs$0() + "msec"));
   return result;
 }
 // ********** Code for FrogOptions **************
 function FrogOptions(homedir, args, files) {
   this.legOnly = false;
   this.throwOnFatal = false;
   this.maxInferenceIterations = (4);
   this.config = "dev";
@@ skipping 21 matching lines @@
   else {
     $globals.world.error(("Invalid configuration " + this.config));
     $throw("Invalid configuration");
   }
   var ignoreUnrecognizedFlags = false;
   var passedLibDir = false;
   this.childArgs = [];
   loop:
   for (var i = (2);
    i < args.get$length(); i++) {
-    var arg = args.$index(i);
+    var arg = args[i];
     switch (arg) {
       case "--enable_leg":
 
         this.enableLeg = true;
         break;
 
       case "--leg_only":
 
         this.enableLeg = true;
         this.legOnly = true;
@@ skipping 72 matching lines @@
 
       case "--Xinfer_types":
 
         this.inferTypes = true;
         break;
 
       default:
 
         if (arg.endsWith$1(".dart")) {
           this.dartScript = arg;
-          this.childArgs = args.getRange$2(i + (1), args.get$length() - i - (1));
+          this.childArgs = args.getRange($add(i, (1)), args.get$length() - i - (1));
           break loop;
         }
         else if (arg.startsWith$1("--out=")) {
           this.outfile = arg.substring$1("--out=".length);
         }
         else if (arg.startsWith$1("--libdir=")) {
           this.libDir = arg.substring$1("--libdir=".length);
           passedLibDir = true;
         }
         else {
@@ skipping 137 matching lines @@
     }
     else {
       code.writeln(("" + this.body + ";"));
       code.exitBlock(suffix);
     }
   }
 }
 VarMethodStub.prototype._needsExactTypeCheck = function() {
   var $this = this; // closure support
   if (this.member == null || this.member.declaringType.get$isObject()) return false;
-  var members = this.member.declaringType.resolveMember(this.member.name).members;
+  var members = this.member.get$potentialMemberSet().members;
   return members.filter$1((function (m) {
     return $ne(m, $this.member) && m.get$declaringType().get$isHiddenNativeType();
   })
   ).get$length() >= (1);
 }
 VarMethodStub.prototype._useDirectCall = function(args) {
   if ((this.member instanceof MethodMember) && !this.member.declaringType.get$hasNativeSubtypes()) {
     var method = this.member;
     if (method.needsArgumentConversion(args)) {
       return false;
     }
     for (var i = args.get$length();
      i < method.parameters.get$length(); i++) {
-      if ($ne(method.parameters.$index(i).get$value().get$code(), "null")) {
+      if ($ne(method.parameters[i].get$value().get$code(), "null")) {
         return false;
       }
     }
     return method.namesInHomePositions(args);
   }
   else {
     return false;
   }
 }
 VarMethodStub.prototype.generate$1 = VarMethodStub.prototype.generate;
@@ skipping 12 matching lines @@
 VarMethodSet.prototype.invoke = function(context, node, target, args) {
   this._invokeMembers(context, node);
   return VarMember.prototype.invoke.call(this, context, node, target, args);
 }
 VarMethodSet.prototype._invokeMembers = function(context, node) {
   if (this.invoked) return;
   this.invoked = true;
   var hasObjectType = false;
   var $$list = this.members;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var member = $$list.$index($$i);
+    var member = $$list[$$i];
     var type = member.get$declaringType();
     var target = new Value(type, "this", node.span);
     var result = member.invoke$4$isDynamic(context, node, target, this.args, true);
     var stub = new VarMethodStub(this.name, member, this.args, "return " + result.get$code());
     type.get$varStubs().$setindex(stub.get$name(), stub);
     if (type.get$isObject()) hasObjectType = true;
   }
   if (!hasObjectType) {
     var target = new Value($globals.world.objectType, "this", node.span);
     var result = target.invokeNoSuchMethod$4(context, this.baseName, node, this.args);
@@ skipping 10 matching lines @@
 function _otherOperator(jsname, op) {
   return ("function " + jsname + "(x, y) {\n  return (typeof(x) == 'number' && typeof(y) == 'number')\n    ? x " + op + " y : x." + jsname + "(y);\n}");
 }
 function map(source, mapper) {
   var result = new Array();
   if (!!(source && source.is$List())) {
     var list = source;
     result.set$length(list.get$length());
     for (var i = (0);
      i < list.get$length(); i++) {
-      result.$setindex(i, mapper(list.$index(i)));
+      result.$setindex(i, mapper.call$1(list[i]));
     }
   }
   else {
     for (var $$i = source.iterator$0(); $$i.hasNext$0(); ) {
       var item = $$i.next$0();
-      result.add(mapper(item));
+      result.add(mapper.call$1(item));
     }
   }
   return result;
 }
 function reduce(source, callback, initialValue) {
   var i = source.iterator$0();
   var current = initialValue;
   if (current == null && i.hasNext$0()) {
     current = i.next$0();
   }
   while (i.hasNext$0()) {
     current = callback.call$2(current, i.next$0());
   }
   return current;
 }
 function orderValuesByKeys(map) {
   var keys = map.getKeys();
   keys.sort((function (x, y) {
     return x.compareTo$1(y);
   })
   );
   var values = [];
   for (var $$i = 0;$$i < keys.get$length(); $$i++) {
-    var k = keys.$index($$i);
+    var k = keys[$$i];
     values.add$1(map.$index(k));
   }
   return values;
 }
 var world;
 var experimentalAwaitPhase;
 var legCompile;
 function initializeWorld(files) {
   $globals.world = new World(files);
   $globals.world.init();
@@ skipping 16 matching lines @@
     if (name0.contains$1("$")) {
       nameBuilder.add$1(("" + name0.get$length()));
     }
     nameBuilder.add$1(name0);
   }
   return nameBuilder.toString$0();
 }
 //  ********** Library minfrog **************
 // ********** Code for top level **************
 function main() {
-  var homedir = path.dirname(fs.realpathSync(get$process().get$argv().$index((1))));
+  var homedir = path.dirname(fs.realpathSync(get$process().get$argv()[(1)]));
   var argv = [];
   for (var i = (0);
    i < get$process().get$argv().get$length(); i++) {
-    argv.add$1(get$process().get$argv().$index(i));
+    argv.add$1(get$process().get$argv()[i]);
     if (i == (1)) {
       var terminal = get$process().get$env().$index("TERM");
       if (terminal == null || !terminal.startsWith$1("xterm")) {
         argv.add$1("--no_colors");
       }
     }
   }
   if (compile(homedir, argv, new NodeFileSystem())) {
     var code = $globals.world.getGeneratedCode();
     if ($globals.options.compileOnly) {
@@ skipping 38 matching lines @@
   $globals._RED_COLOR = "\x1b[31m";
 }
 var const$0000 = Object.create(EmptyQueueException.prototype, {});
 var const$0001 = Object.create(_DeletedKeySentinel.prototype, {});
 var const$0005 = Object.create(NoMoreElementsException.prototype, {});
 var const$0007 = Object.create(IllegalAccessException.prototype, {});
 var const$0008 = ImmutableList.ImmutableList$from$factory([]);
 var $globals = {};
 $static_init();
 main();