fixes #52, fields shadowing getters/setters or other fields

lib/runtime/dart/_js_helper.js

 var _js_helper;
 (function(exports) {
   'use strict';
   class NoSideEffects extends core.Object {
     NoSideEffects() {
     }
   }
   class NoThrows extends core.Object {
     NoThrows() {
     }
   }
   class NoInline extends core.Object {
     NoInline() {
     }
   }
+  let value$ = Symbol('value');
   class IrRepresentation extends core.Object {
+    get value() {
+      return this[value$];
+    }
     IrRepresentation(value) {
-      this.value = value;
+      this[value$] = value;
     }
   }
+  let name$ = Symbol('name');
   class Native extends core.Object {
+    get name() {
+      return this[name$];
+    }
     Native(name) {
-      this.name = name;
+      this[name$] = name;
     }
   }
   let _ = Symbol('_');
   let _throwUnmodifiable = Symbol('_throwUnmodifiable');
   let ConstantMap$ = dart.generic(function(K, V) {
     class ConstantMap extends core.Object {
       [_]() {
       }
       get isEmpty() {
         return this.length == 0;
@@ skipping 21 matching lines @@
       }
       addAll(other) {
         return this[_throwUnmodifiable]();
       }
     }
     ConstantMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(ConstantMap, _);
     return ConstantMap;
   });
   let ConstantMap = ConstantMap$();
+  let length$ = Symbol('length');
   let _jsObject = Symbol('_jsObject');
   let _keys = Symbol('_keys');
   let _fetch = Symbol('_fetch');
   let ConstantStringMap$ = dart.generic(function(K, V) {
     class ConstantStringMap extends ConstantMap$(K, V) {
       [_](length, jsObject, keys) {
-        this.length = length;
+        this[length$] = length;
         this[_jsObject] = jsObject;
         this[_keys] = keys;
         super[_]();
       }
+      get length() {
+        return this[length$];
+      }
       containsValue(needle) {
         return this.values[core.$any](value => dart.equals(value, needle));
       }
       containsKey(key) {
         if (!(typeof key == 'string'))
           return false;
         if (dart.equals('__proto__', key))
           return false;
         return jsHasOwnProperty(this[_jsObject], dart.as(key, core.String));
       }
@@ skipping 374 matching lines @@
     nativeRegexp.lastIndex = 0;
     return nativeRegexp;
   }
   let _nativeAnchoredVersion = Symbol('_nativeAnchoredVersion');
   // Function regExpCaptureCount: (JSSyntaxRegExp) → int
   function regExpCaptureCount(regexp) {
     let nativeAnchoredRegExp = regexp[_nativeAnchoredVersion];
     let match = nativeAnchoredRegExp.exec('');
     return dart.as(dart.dsend(dart.dload(match, 'length'), '-', 2), core.int);
   }
+  let pattern = Symbol('pattern');
   let _nativeGlobalRegExp = Symbol('_nativeGlobalRegExp');
   let _nativeAnchoredRegExp = Symbol('_nativeAnchoredRegExp');
   let _isMultiLine = Symbol('_isMultiLine');
   let _isCaseSensitive = Symbol('_isCaseSensitive');
   let _execGlobal = Symbol('_execGlobal');
   let _execAnchored = Symbol('_execAnchored');
   class JSSyntaxRegExp extends core.Object {
+    get pattern() {
+      return this[pattern];
+    }
     toString() {
       return `RegExp/${this.pattern}/`;
     }
     JSSyntaxRegExp(source, opts) {
       let multiLine = opts && 'multiLine' in opts ? opts.multiLine : false;
       let caseSensitive = opts && 'caseSensitive' in opts ? opts.caseSensitive : true;
-      this.pattern = source;
+      this[pattern] = source;
       this[_nativeRegExp] = JSSyntaxRegExp.makeNative(source, multiLine, caseSensitive, false);
       this[_nativeGlobalRegExp] = null;
       this[_nativeAnchoredRegExp] = null;
     }
     get [_nativeGlobalVersion]() {
       if (this[_nativeGlobalRegExp] != null)
         return this[_nativeGlobalRegExp];
       return this[_nativeGlobalRegExp] = JSSyntaxRegExp.makeNative(this.pattern, this[_isMultiLine], this[_isCaseSensitive], true);
     }
     get [_nativeAnchoredVersion]() {
@@ skipping 165 matching lines @@
       this[_current] = null;
       this[_string] = null;
       return false;
     }
   }
   _AllMatchesIterator[dart.implements] = () => [core.Iterator$(core.Match)];
   // Function firstMatchAfter: (JSSyntaxRegExp, String, int) → Match
   function firstMatchAfter(regExp, string, start) {
     return regExp[_execGlobal](string, start);
   }
+  let start$ = Symbol('start');
+  let input$ = Symbol('input');
+  let pattern$ = Symbol('pattern');
   class StringMatch extends core.Object {
     StringMatch(start, input, pattern) {
-      this.start = start;
-      this.input = input;
-      this.pattern = pattern;
+      this[start$] = start;
+      this[input$] = input;
+      this[pattern$] = pattern;
     }
     get end() {
       return dart.notNull(this.start) + dart.notNull(this.pattern.length);
     }
     get(g) {
       return this.group(g);
     }
     get groupCount() {
       return 0;
     }
     group(group_) {
       if (group_ != 0) {
         throw new core.RangeError.value(group_);
       }
       return this.pattern;
     }
     groups(groups_) {
       let result = new (core.List$(core.String))();
       for (let g of groups_) {
         result[core.$add](this.group(g));
       }
       return result;
     }
+    get start() {
+      return this[start$];
+    }
+    get input() {
+      return this[input$];
+    }
+    get pattern() {
+      return this[pattern$];
+    }
   }
   StringMatch[dart.implements] = () => [core.Match];
   // Function allMatchesInStringUnchecked: (String, String, int) → List<Match>
   function allMatchesInStringUnchecked(needle, haystack, startIndex) {
     let result = new (core.List$(core.Match))();
     let length = haystack.length;
     let patternLength = needle.length;
     while (true) {
       let position = haystack.indexOf(needle, startIndex);
       if (position == -1) {
@@ skipping 181 matching lines @@
       return this[_unmangledName] = unmangledName;
     }
     get hashCode() {
       return this[_typeName].hashCode;
     }
     ['=='](other) {
       return dart.is(other, TypeImpl) && dart.equals(this[_typeName], dart.dload(other, _typeName));
     }
   }
   TypeImpl[dart.implements] = () => [core.Type];
+  let owner$ = Symbol('owner');
+  let name$0 = Symbol('name');
+  let bound$ = Symbol('bound');
   class TypeVariable extends core.Object {
+    get owner() {
+      return this[owner$];
+    }
+    get name() {
+      return this[name$0];
+    }
+    get bound() {
+      return this[bound$];
+    }
     TypeVariable(owner, name, bound) {
-      this.owner = owner;
-      this.name = name;
-      this.bound = bound;
+      this[owner$] = owner;
+      this[name$0] = name;
+      this[bound$] = bound;
     }
   }
   // Function getMangledTypeName: (TypeImpl) → dynamic
   function getMangledTypeName(type) {
     return type[_typeName];
   }
   // Function setRuntimeTypeInfo: (Object, dynamic) → Object
   function setRuntimeTypeInfo(target, typeInfo) {
     dart.assert(dart.notNull(typeInfo == null) || dart.notNull(isJsArray(typeInfo)));
     if (target != null)
@@ skipping 600 matching lines @@
       }
     }
     static getCachedInvocation(invocation, victim) {
       return invocation[_getCachedInvocation](victim);
     }
   }
   JSInvocationMirror[dart.implements] = () => [core.Invocation];
   JSInvocationMirror.METHOD = 0;
   JSInvocationMirror.GETTER = 1;
   JSInvocationMirror.SETTER = 2;
+  let mangledName$ = Symbol('mangledName');
+  let jsFunction$ = Symbol('jsFunction');
+  let isIntercepted$ = Symbol('isIntercepted');
+  let cachedInterceptor$ = Symbol('cachedInterceptor');
   class CachedInvocation extends core.Object {
+    get mangledName() {
+      return this[mangledName$];
+    }
+    set mangledName(value) {
+      this[mangledName$] = value;
+    }
+    get jsFunction() {
+      return this[jsFunction$];
+    }
+    set jsFunction(value) {
+      this[jsFunction$] = value;
+    }
+    get isIntercepted() {
+      return this[isIntercepted$];
+    }
+    set isIntercepted(value) {
+      this[isIntercepted$] = value;
+    }
+    get cachedInterceptor() {
+      return this[cachedInterceptor$];
+    }
+    set cachedInterceptor(value) {
+      this[cachedInterceptor$] = value;
+    }
     CachedInvocation(mangledName, jsFunction, isIntercepted, cachedInterceptor) {
-      this.mangledName = mangledName;
-      this.jsFunction = jsFunction;
-      this.isIntercepted = isIntercepted;
-      this.cachedInterceptor = cachedInterceptor;
+      this[mangledName$] = mangledName;
+      this[jsFunction$] = jsFunction;
+      this[isIntercepted$] = isIntercepted;
+      this[cachedInterceptor$] = cachedInterceptor;
     }
     get isNoSuchMethod() {
       return false;
     }
     get isGetterStub() {
       return !!this.jsFunction.$getterStub;
     }
     invokeOn(victim, arguments$) {
       let receiver = victim;
       if (!dart.notNull(this.isIntercepted)) {
         if (!dart.is(arguments$, _interceptors.JSArray))
           arguments$ = new core.List.from(arguments$);
       } else {
         let _ = new core.List.from([victim]);
         _[core.$addAll](arguments$);
         arguments$ = _;
         if (this.cachedInterceptor != null)
           receiver = this.cachedInterceptor;
       }
       return this.jsFunction.apply(receiver, arguments$);
     }
   }
+  let info = Symbol('info');
   class CachedCatchAllInvocation extends CachedInvocation {
+    get info() {
+      return this[info];
+    }
     CachedCatchAllInvocation(name, jsFunction, isIntercepted, cachedInterceptor) {
-      this.info = new ReflectionInfo(jsFunction);
+      this[info] = new ReflectionInfo(jsFunction);
       super.CachedInvocation(name, jsFunction, isIntercepted, cachedInterceptor);
     }
     get isGetterStub() {
       return false;
     }
     invokeOn(victim, arguments$) {
       let receiver = victim;
       let providedArgumentCount = null;
       let fullParameterCount = dart.notNull(this.info.requiredParameterCount) + dart.notNull(this.info.optionalParameterCount);
       if (!dart.notNull(this.isIntercepted)) {
@@ skipping 20 matching lines @@
         throw new UnimplementedNoSuchMethodError(`Invocation of unstubbed method '${this.info.reflectionName}'` + ` with ${providedArgumentCount} arguments (too few).`);
       } else if (dart.notNull(providedArgumentCount) > dart.notNull(fullParameterCount)) {
         throw new UnimplementedNoSuchMethodError(`Invocation of unstubbed method '${this.info.reflectionName}'` + ` with ${providedArgumentCount} arguments (too many).`);
       }
       for (let i = providedArgumentCount; dart.notNull(i) < dart.notNull(fullParameterCount); i = dart.notNull(i) + 1) {
         arguments$[core.$add](getMetadata(this.info.defaultValue(i)));
       }
       return this.jsFunction.apply(receiver, arguments$);
     }
   }
+  let interceptor$ = Symbol('interceptor');
   class CachedNoSuchMethodInvocation extends core.Object {
+    get interceptor() {
+      return this[interceptor$];
+    }
+    set interceptor(value) {
+      this[interceptor$] = value;
+    }
     CachedNoSuchMethodInvocation(interceptor) {
-      this.interceptor = interceptor;
+      this[interceptor$] = interceptor;
     }
     get isNoSuchMethod() {
       return true;
     }
     get isGetterStub() {
       return false;
     }
     invokeOn(victim, invocation) {
       let receiver = this.interceptor == null ? victim : this.interceptor;
       return dart.dsend(receiver, 'noSuchMethod', invocation);
     }
   }
+  let jsFunction$0 = Symbol('jsFunction');
+  let data$ = Symbol('data');
+  let isAccessor$ = Symbol('isAccessor');
+  let requiredParameterCount$ = Symbol('requiredParameterCount');
+  let optionalParameterCount$ = Symbol('optionalParameterCount');
+  let areOptionalParametersNamed$ = Symbol('areOptionalParametersNamed');
+  let functionType$ = Symbol('functionType');
+  let cachedSortedIndices = Symbol('cachedSortedIndices');
   class ReflectionInfo extends core.Object {
+    get jsFunction() {
+      return this[jsFunction$0];
+    }
+    get data() {
+      return this[data$];
+    }
+    get isAccessor() {
+      return this[isAccessor$];
+    }
+    get requiredParameterCount() {
+      return this[requiredParameterCount$];
+    }
+    get optionalParameterCount() {
+      return this[optionalParameterCount$];
+    }
+    get areOptionalParametersNamed() {
+      return this[areOptionalParametersNamed$];
+    }
+    get functionType() {
+      return this[functionType$];
+    }
+    get cachedSortedIndices() {
+      return this[cachedSortedIndices];
+    }
+    set cachedSortedIndices(value) {
+      this[cachedSortedIndices] = value;
+    }
     internal(jsFunction, data, isAccessor, requiredParameterCount, optionalParameterCount, areOptionalParametersNamed, functionType) {
-      this.jsFunction = jsFunction;
-      this.data = data;
-      this.isAccessor = isAccessor;
-      this.requiredParameterCount = requiredParameterCount;
-      this.optionalParameterCount = optionalParameterCount;
-      this.areOptionalParametersNamed = areOptionalParametersNamed;
-      this.functionType = functionType;
-      this.cachedSortedIndices = null;
+      this[jsFunction$0] = jsFunction;
+      this[data$] = data;
+      this[isAccessor$] = isAccessor;
+      this[requiredParameterCount$] = requiredParameterCount;
+      this[optionalParameterCount$] = optionalParameterCount;
+      this[areOptionalParametersNamed$] = areOptionalParametersNamed;
+      this[functionType$] = functionType;
+      this[cachedSortedIndices] = null;
     }
     ReflectionInfo(jsFunction) {
       let data = dart.as(jsFunction.$reflectionInfo, core.List);
       if (data == null)
         return null;
       data = _interceptors.JSArray.markFixedList(data);
       let requiredParametersInfo = data[ReflectionInfo.REQUIRED_PARAMETERS_INFO];
       let requiredParameterCount = requiredParametersInfo >> 1;
       let isAccessor = (dart.notNull(requiredParametersInfo) & 1) == 1;
       let optionalParametersInfo = data[ReflectionInfo.OPTIONAL_PARAMETERS_INFO];
@@ skipping 1299 matching lines @@
     return jsObject.hasOwnProperty(property);
   }
   // Function jsPropertyAccess: (dynamic, String) → dynamic
   function jsPropertyAccess(jsObject, property) {
     return jsObject[property];
   }
   // Function getFallThroughError: () → dynamic
   function getFallThroughError() {
     return new FallThroughErrorImplementation();
   }
+  let types$ = Symbol('types');
   class Creates extends core.Object {
+    get types() {
+      return this[types$];
+    }
     Creates(types) {
-      this.types = types;
+      this[types$] = types;
     }
   }
+  let types$0 = Symbol('types');
   class Returns extends core.Object {
+    get types() {
+      return this[types$0];
+    }
     Returns(types) {
-      this.types = types;
+      this[types$0] = types;
     }
   }
+  let name$1 = Symbol('name');
   class JSName extends core.Object {
+    get name() {
+      return this[name$1];
+    }
     JSName(name) {
-      this.name = name;
+      this[name$1] = name;
     }
   }
   // Function boolConversionCheck: (dynamic) → dynamic
   function boolConversionCheck(value) {
     if (typeof value == 'boolean')
       return value;
     boolTypeCheck(value);
     dart.assert(value != null);
     return false;
   }
@@ skipping 251 matching lines @@
     if (!dart.notNull(exports._loadedLibraries[core.$contains](loadId))) {
       throw new DeferredNotLoadedError(uri);
     }
   }
   dart.defineLazyClass(exports, {
     get JavaScriptIndexingBehavior() {
       class JavaScriptIndexingBehavior extends _interceptors.JSMutableIndexable {}
       return JavaScriptIndexingBehavior;
     }
   });
+  let message$ = Symbol('message');
   class TypeErrorImplementation extends core.Error {
+    get message() {
+      return this[message$];
+    }
     TypeErrorImplementation(value, type) {
-      this.message = `type '${Primitives.objectTypeName(value)}' is not a subtype ` + `of type '${type}'`;
+      this[message$] = `type '${Primitives.objectTypeName(value)}' is not a subtype ` + `of type '${type}'`;
       super.Error();
     }
     fromMessage(message) {
-      this.message = message;
+      this[message$] = message;
       super.Error();
     }
     toString() {
       return this.message;
     }
   }
   TypeErrorImplementation[dart.implements] = () => [core.TypeError];
   dart.defineNamedConstructor(TypeErrorImplementation, 'fromMessage');
+  let message = Symbol('message');
   class CastErrorImplementation extends core.Error {
+    get message() {
+      return this[message];
+    }
     CastErrorImplementation(actualType, expectedType) {
-      this.message = `CastError: Casting value of type ${actualType} to` + ` incompatible type ${expectedType}`;
+      this[message] = `CastError: Casting value of type ${actualType} to` + ` incompatible type ${expectedType}`;
       super.Error();
     }
     toString() {
       return this.message;
     }
   }
   CastErrorImplementation[dart.implements] = () => [core.CastError];
   class FallThroughErrorImplementation extends core.FallThroughError {
     FallThroughErrorImplementation() {
       super.FallThroughError();
@@ skipping 16 matching lines @@
   }
   // Function throwNoSuchMethod: (dynamic, dynamic, dynamic, dynamic) → void
   function throwNoSuchMethod(obj, name, arguments$, expectedArgumentNames) {
     let memberName = new _internal.Symbol.unvalidated(dart.as(name, core.String));
     throw new core.NoSuchMethodError(obj, memberName, dart.as(arguments$, core.List), new (core.Map$(core.Symbol, dart.dynamic))(), dart.as(expectedArgumentNames, core.List));
   }
   // Function throwCyclicInit: (String) → void
   function throwCyclicInit(staticName) {
     throw new core.CyclicInitializationError(`Cyclic initialization for static ${staticName}`);
   }
+  let message$0 = Symbol('message');
   class RuntimeError extends core.Error {
+    get message() {
+      return this[message$0];
+    }
     RuntimeError(message) {
-      this.message = message;
+      this[message$0] = message;
       super.Error();
     }
     toString() {
       return `RuntimeError: ${this.message}`;
     }
   }
+  let libraryName$ = Symbol('libraryName');
   class DeferredNotLoadedError extends core.Error {
+    get libraryName() {
+      return this[libraryName$];
+    }
+    set libraryName(value) {
+      this[libraryName$] = value;
+    }
     DeferredNotLoadedError(libraryName) {
-      this.libraryName = libraryName;
+      this[libraryName$] = libraryName;
       super.Error();
     }
     toString() {
       return `Deferred library ${this.libraryName} was not loaded.`;
     }
   }
   DeferredNotLoadedError[dart.implements] = () => [core.NoSuchMethodError];
   class RuntimeType extends core.Object {
     RuntimeType() {
     }
   }
+  let returnType$ = Symbol('returnType');
+  let parameterTypes$ = Symbol('parameterTypes');
+  let optionalParameterTypes$ = Symbol('optionalParameterTypes');
+  let namedParameters$ = Symbol('namedParameters');
   let _isTest = Symbol('_isTest');
   let _extractFunctionTypeObjectFrom = Symbol('_extractFunctionTypeObjectFrom');
   let _asCheck = Symbol('_asCheck');
   let _check = Symbol('_check');
   let _assertCheck = Symbol('_assertCheck');
   class RuntimeFunctionType extends RuntimeType {
+    get returnType() {
+      return this[returnType$];
+    }
+    get parameterTypes() {
+      return this[parameterTypes$];
+    }
+    get optionalParameterTypes() {
+      return this[optionalParameterTypes$];
+    }
+    get namedParameters() {
+      return this[namedParameters$];
+    }
     RuntimeFunctionType(returnType, parameterTypes, optionalParameterTypes, namedParameters) {
-      this.returnType = returnType;
-      this.parameterTypes = parameterTypes;
-      this.optionalParameterTypes = optionalParameterTypes;
-      this.namedParameters = namedParameters;
+      this[returnType$] = returnType;
+      this[parameterTypes$] = parameterTypes;
+      this[optionalParameterTypes$] = optionalParameterTypes;
+      this[namedParameters$] = namedParameters;
       super.RuntimeType();
     }
     get isVoid() {
       return dart.is(this.returnType, VoidRuntimeType);
     }
     [_isTest](expression) {
       let functionTypeObject = this[_extractFunctionTypeObjectFrom](expression);
       return functionTypeObject == null ? false : isFunctionSubtype(functionTypeObject, this.toRti());
     }
     [_asCheck](expression) {
@@ skipping 195 matching lines @@
       for (let i = 1; dart.notNull(i) < dart.notNull(list[core.$length]); i = dart.notNull(i) + 1) {
         arguments$[core.$add](convertRtiToRuntimeType(list[core.$get](i)));
       }
       return new RuntimeTypeGeneric(name, dart.as(arguments$, core.List$(RuntimeType)), rti);
     } else if ("func" in rti) {
       return new FunctionTypeInfoDecoderRing(rti).toRuntimeType();
     } else {
       throw new RuntimeError("Cannot convert " + `'${JSON.stringify(rti)}' to RuntimeType.`);
     }
   }
+  let name$2 = Symbol('name');
   class RuntimeTypePlain extends RuntimeType {
+    get name() {
+      return this[name$2];
+    }
     RuntimeTypePlain(name) {
-      this.name = name;
+      this[name$2] = name;
       super.RuntimeType();
     }
     toRti() {
       let allClasses = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.ALL_CLASSES);
       let rti = allClasses[this.name];
       if (rti == null)
         throw `no type for '${this.name}'`;
       return rti;
     }
     toString() {
       return this.name;
     }
   }
+  let name$3 = Symbol('name');
+  let arguments$0 = Symbol('arguments');
+  let rti$ = Symbol('rti');
   class RuntimeTypeGeneric extends RuntimeType {
+    get name() {
+      return this[name$3];
+    }
+    get arguments() {
+      return this[arguments$0];
+    }
+    get rti() {
+      return this[rti$];
+    }
+    set rti(value) {
+      this[rti$] = value;
+    }
     RuntimeTypeGeneric(name, arguments$, rti) {
-      this.name = name;
-      this.arguments = arguments$;
-      this.rti = rti;
+      this[name$3] = name;
+      this[arguments$0] = arguments$;
+      this[rti$] = rti;
       super.RuntimeType();
     }
     toRti() {
       if (this.rti != null)
         return this.rti;
       let allClasses = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.ALL_CLASSES);
       let result = [allClasses[this.name]];
       if (dart.dindex(result, 0) == null) {
         throw `no type for '${this.name}<...>'`;
       }
@@ skipping 487 matching lines @@
   exports.jsonEncodeNative = jsonEncodeNative;
   exports.getIsolateAffinityTag = getIsolateAffinityTag;
   exports.LoadLibraryFunctionType = LoadLibraryFunctionType;
   exports.DeferredLoadCallback = DeferredLoadCallback;
   exports.loadDeferredLibrary = loadDeferredLibrary;
   exports.MainError = MainError;
   exports.missingMain = missingMain;
   exports.badMain = badMain;
   exports.mainHasTooManyParameters = mainHasTooManyParameters;
 })(_js_helper || (_js_helper = {}));