partially implement instance of checks and some codegen fixes

lib/runtime/dart/_interceptors.js

 var _interceptors;
 (function(exports) {
   'use strict';
   class Interceptor extends core.Object {
     Interceptor() {
     }
     ['=='](other) {
       return core.identical(this, other);
     }
     get hashCode() {
@@ skipping 11 matching lines @@
   }
   let JSArray$ = dart.generic(function(E) {
     class JSArray extends Interceptor {
       JSArray() {
         super.Interceptor();
       }
       fixed(length) {
         if (dart.notNull(!(typeof length == 'number')) || dart.notNull(length) < 0) {
           throw new core.ArgumentError(`Length must be a non-negative integer: ${length}`);
         }
-        return new JSArray.markFixed(new Array(length));
+        return new JSArray$(E).markFixed(new Array(length));
       }
       emptyGrowable() {
-        return new JSArray.markGrowable([]);
+        return new JSArray$(E).markGrowable([]);
       }
       growable(length) {
         if (dart.notNull(!(typeof length == 'number')) || dart.notNull(length) < 0) {
           throw new core.ArgumentError(`Length must be a non-negative integer: ${length}`);
         }
-        return new JSArray.markGrowable(new Array(length));
+        return new JSArray$(E).markGrowable(new Array(length));
       }
       typed(allocation) {
         return dart.as(allocation, JSArray$(E));
       }
       markFixed(allocation) {
-        return dart.as(JSArray.markFixedList(new JSArray.typed(allocation)), JSArray$(E));
+        return dart.as(JSArray.markFixedList(new JSArray$(E).typed(allocation)), JSArray$(E));
       }
       markGrowable(allocation) {
-        return dart.as(new JSArray.typed(allocation), JSArray$(E));
+        return dart.as(new JSArray$(E).typed(allocation), JSArray$(E));
       }
       static markFixedList(list) {
         list.fixed$length = Array;
         return dart.as(list, core.List);
       }
       checkMutable(reason) {
         if (!dart.is(this, JSMutableArray)) {
           throw new core.UnsupportedError(dart.as(reason, core.String));
         }
       }
@@ skipping 48 matching lines @@
         }
         return false;
       }
       removeWhere(test) {
         _internal.IterableMixinWorkaround.removeWhereList(this, test);
       }
       retainWhere(test) {
         _internal.IterableMixinWorkaround.removeWhereList(this, (element) => !dart.notNull(test(element)));
       }
       where(f) {
-        return new _internal.IterableMixinWorkaround().where(this, f);
+        return new (_internal.IterableMixinWorkaround$(E))().where(this, f);
       }
       expand(f) {
         return _internal.IterableMixinWorkaround.expand(this, f);
       }
       addAll(collection) {
         for (let e of collection) {
           this.add(e);
         }
       }
       clear() {
@@ skipping 14 matching lines @@
       join(separator) {
         if (separator === void 0)
           separator = "";
         let list = new core.List(this.length);
         for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
           list.set(i, `${this.get(i)}`);
         }
         return list.join(separator);
       }
       take(n) {
-        return new _internal.IterableMixinWorkaround().takeList(this, n);
+        return new (_internal.IterableMixinWorkaround$(E))().takeList(this, n);
       }
       takeWhile(test) {
-        return new _internal.IterableMixinWorkaround().takeWhile(this, test);
+        return new (_internal.IterableMixinWorkaround$(E))().takeWhile(this, test);
       }
       skip(n) {
-        return new _internal.IterableMixinWorkaround().skipList(this, n);
+        return new (_internal.IterableMixinWorkaround$(E))().skipList(this, n);
       }
       skipWhile(test) {
-        return new _internal.IterableMixinWorkaround().skipWhile(this, test);
+        return new (_internal.IterableMixinWorkaround$(E))().skipWhile(this, test);
       }
       reduce(combine) {
         return dart.as(_internal.IterableMixinWorkaround.reduce(this, combine), E);
       }
       fold(initialValue, combine) {
         return _internal.IterableMixinWorkaround.fold(this, initialValue, combine);
       }
       firstWhere(test, opts) {
         let orElse = opts && 'orElse' in opts ? opts.orElse : null;
         return dart.as(_internal.IterableMixinWorkaround.firstWhere(this, test, orElse), E);
@@ skipping 21 matching lines @@
           end = this.length;
         } else {
           if (!(typeof end == 'number'))
             throw new core.ArgumentError(end);
           if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(this.length)) {
             throw new core.RangeError.range(end, start, this.length);
           }
         }
         if (start == end)
           return new core.List$(E).from([]);
-        return new JSArray.markGrowable(this.slice(start, end));
+        return new JSArray$(E).markGrowable(this.slice(start, end));
       }
       getRange(start, end) {
-        return new _internal.IterableMixinWorkaround().getRangeList(this, start, end);
+        return new (_internal.IterableMixinWorkaround$(E))().getRangeList(this, start, end);
       }
       get first() {
         if (dart.notNull(this.length) > 0)
           return this.get(0);
         throw new core.StateError("No elements");
       }
       get last() {
         if (dart.notNull(this.length) > 0)
           return this.get(dart.notNull(this.length) - 1);
         throw new core.StateError("No elements");
@@ skipping 33 matching lines @@
         this.checkGrowable('removeRange');
         _internal.IterableMixinWorkaround.replaceRangeList(this, start, end, iterable);
       }
       any(f) {
         return _internal.IterableMixinWorkaround.any(this, f);
       }
       every(f) {
         return _internal.IterableMixinWorkaround.every(this, f);
       }
       get reversed() {
-        return new _internal.IterableMixinWorkaround().reversedList(this);
+        return new (_internal.IterableMixinWorkaround$(E))().reversedList(this);
       }
       sort(compare) {
         if (compare === void 0)
           compare = null;
         this.checkMutable('sort');
         _internal.IterableMixinWorkaround.sortList(this, compare);
       }
       shuffle(random) {
         if (random === void 0)
           random = null;
@@ skipping 21 matching lines @@
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       toString() {
         return collection.ListBase.listToString(this);
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         if (growable) {
-          return new JSArray.markGrowable(this.slice());
+          return new JSArray$(E).markGrowable(this.slice());
         } else {
-          return new JSArray.markFixed(this.slice());
+          return new JSArray$(E).markFixed(this.slice());
         }
       }
       toSet() {
-        return new core.Set.from(this);
+        return new core.Set$(E).from(this);
       }
       get iterator() {
-        return new _internal.ListIterator(this);
+        return new (_internal.ListIterator$(E))(this);
       }
       get hashCode() {
         return _js_helper.Primitives.objectHashCode(this);
       }
       get length() {
         return dart.as(this.length, core.int);
       }
       set length(newLength) {
         if (!(typeof newLength == 'number'))
           throw new core.ArgumentError(newLength);
@@ skipping 11 matching lines @@
       }
       set(index, value) {
         this.checkMutable('indexed set');
         if (!(typeof index == 'number'))
           throw new core.ArgumentError(index);
         if (dart.notNull(index) >= dart.notNull(this.length) || dart.notNull(index) < 0)
           throw new core.RangeError.value(index);
         this[index] = value;
       }
       asMap() {
-        return new _internal.IterableMixinWorkaround().asMapList(this);
+        return new (_internal.IterableMixinWorkaround$(E))().asMapList(this);
       }
     }
     JSArray[dart.implements] = () => [core.List$(E), JSIndexable];
     dart.defineNamedConstructor(JSArray, 'fixed');
     dart.defineNamedConstructor(JSArray, 'emptyGrowable');
     dart.defineNamedConstructor(JSArray, 'growable');
     dart.defineNamedConstructor(JSArray, 'typed');
     dart.defineNamedConstructor(JSArray, 'markFixed');
     dart.defineNamedConstructor(JSArray, 'markGrowable');
     return JSArray;
@@ skipping 850 matching lines @@
     }
   }
   // Function _symbolToString: (Symbol) → String
   function _symbolToString(symbol) {
     return _internal.Symbol.getName(dart.as(symbol, _internal.Symbol));
   }
   // Function _symbolMapToStringMap: (Map<Symbol, dynamic>) → dynamic
   function _symbolMapToStringMap(map) {
     if (map == null)
       return null;
-    let result = new core.Map();
+    let result = new (core.Map$(core.String, dynamic))();
     map.forEach((key, value) => {
       result.set(_symbolToString(key), value);
     });
     return result;
   }
   // Function getInterceptor: (dynamic) → dynamic
   function getInterceptor(object) {
     return void 0;
   }
   // Function getDispatchProperty: (dynamic) → dynamic
@@ skipping 201 matching lines @@
   exports.findInterceptorForType = findInterceptorForType;
   exports.JSBool = JSBool;
   exports.JSNull = JSNull;
   exports.JSIndexable = JSIndexable;
   exports.JSMutableIndexable = JSMutableIndexable;
   exports.JSObject = JSObject;
   exports.JavaScriptObject = JavaScriptObject;
   exports.PlainJavaScriptObject = PlainJavaScriptObject;
   exports.UnknownJavaScriptObject = UnknownJavaScriptObject;
 })(_interceptors || (_interceptors = {}));