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() {
     }
   }
   class IrRepresentation extends core.Object {
     IrRepresentation(value) {
-      this.value = value;
+      dart.initField(IrRepresentation, this, 'value', value);
     }
   }
   class Native extends core.Object {
     Native(name) {
-      this.name = name;
+      dart.initField(Native, 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 27 matching lines @@
     dart.defineNamedConstructor(ConstantMap, _);
     return ConstantMap;
   });
   let ConstantMap = ConstantMap$();
   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;
+        dart.initField(ConstantStringMap, this, 'length', length);
         this[_jsObject] = jsObject;
         this[_keys] = keys;
         super[_]();
       }
       containsValue(needle) {
         return this.values[core.$any](value => dart.equals(value, needle));
       }
       containsKey(key) {
         if (!(typeof key == 'string'))
           return false;
@@ skipping 391 matching lines @@
   let _isCaseSensitive = Symbol('_isCaseSensitive');
   let _execGlobal = Symbol('_execGlobal');
   let _execAnchored = Symbol('_execAnchored');
   class JSSyntaxRegExp extends core.Object {
     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[_nativeRegExp] = JSSyntaxRegExp.makeNative(source, multiLine, caseSensitive, false);
-      this[_nativeGlobalRegExp] = null;
-      this[_nativeAnchoredRegExp] = null;
+      dart.initField(JSSyntaxRegExp, this, 'pattern', source);
+      dart.initField(JSSyntaxRegExp, this, _nativeRegExp, JSSyntaxRegExp.makeNative(source, multiLine, caseSensitive, false));
+      dart.initField(JSSyntaxRegExp, this, _nativeGlobalRegExp, null);
+      dart.initField(JSSyntaxRegExp, 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]() {
       if (this[_nativeAnchoredRegExp] != null)
         return this[_nativeAnchoredRegExp];
       return this[_nativeAnchoredRegExp] = JSSyntaxRegExp.makeNative(`${this.pattern}|()`, this[_isMultiLine], this[_isCaseSensitive], true);
@@ skipping 164 matching lines @@
       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);
   }
   class StringMatch extends core.Object {
     StringMatch(start, input, pattern) {
-      this.start = start;
-      this.input = input;
-      this.pattern = pattern;
+      dart.initField(StringMatch, this, 'start', start);
+      dart.initField(StringMatch, this, 'input', input);
+      dart.initField(StringMatch, 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;
     }
@@ skipping 187 matching lines @@
     return array.join(separator);
   }
   // Function createRuntimeType: (String) → Type
   function createRuntimeType(name) {
     return new TypeImpl(name);
   }
   let _typeName = Symbol('_typeName');
   let _unmangledName = Symbol('_unmangledName');
   class TypeImpl extends core.Object {
     TypeImpl(typeName) {
-      this[_typeName] = typeName;
-      this[_unmangledName] = null;
+      dart.initField(TypeImpl, this, _typeName, typeName);
+      dart.initField(TypeImpl, this, _unmangledName, null);
     }
     toString() {
       if (this[_unmangledName] != null)
         return this[_unmangledName];
       let unmangledName = _js_names.unmangleAllIdentifiersIfPreservedAnyways(this[_typeName]);
       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];
   class TypeVariable extends core.Object {
     TypeVariable(owner, name, bound) {
-      this.owner = owner;
-      this.name = name;
-      this.bound = bound;
+      dart.initField(TypeVariable, this, 'owner', owner);
+      dart.initField(TypeVariable, this, 'name', name);
+      dart.initField(TypeVariable, 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 483 matching lines @@
   }
   let _memberName = Symbol('_memberName');
   let _internalName = Symbol('_internalName');
   let _kind = Symbol('_kind');
   let _arguments = Symbol('_arguments');
   let _namedArgumentNames = Symbol('_namedArgumentNames');
   let _namedIndices = Symbol('_namedIndices');
   let _getCachedInvocation = Symbol('_getCachedInvocation');
   class JSInvocationMirror extends core.Object {
     JSInvocationMirror(memberName, internalName, kind, arguments$, namedArgumentNames) {
-      this[_memberName] = memberName;
-      this[_internalName] = internalName;
-      this[_kind] = kind;
-      this[_arguments] = arguments$;
-      this[_namedArgumentNames] = namedArgumentNames;
-      this[_namedIndices] = null;
+      dart.initField(JSInvocationMirror, this, _memberName, memberName);
+      dart.initField(JSInvocationMirror, this, _internalName, internalName);
+      dart.initField(JSInvocationMirror, this, _kind, kind);
+      dart.initField(JSInvocationMirror, this, _arguments, arguments$);
+      dart.initField(JSInvocationMirror, this, _namedArgumentNames, namedArgumentNames);
+      dart.initField(JSInvocationMirror, this, _namedIndices, null);
     }
     get memberName() {
       if (dart.is(this[_memberName], core.Symbol))
         return dart.as(this[_memberName], core.Symbol);
       let name = dart.as(this[_memberName], core.String);
       let unmangledName = _js_names.mangledNames.get(name);
       if (unmangledName != null) {
         name = unmangledName.split(':')[core.$get](0);
       } else {
         if (_js_names.mangledNames.get(this[_internalName]) == null) {
@@ skipping 93 matching lines @@
     static getCachedInvocation(invocation, victim) {
       return invocation[_getCachedInvocation](victim);
     }
   }
   JSInvocationMirror[dart.implements] = () => [core.Invocation];
   JSInvocationMirror.METHOD = 0;
   JSInvocationMirror.GETTER = 1;
   JSInvocationMirror.SETTER = 2;
   class CachedInvocation extends core.Object {
     CachedInvocation(mangledName, jsFunction, isIntercepted, cachedInterceptor) {
-      this.mangledName = mangledName;
-      this.jsFunction = jsFunction;
-      this.isIntercepted = isIntercepted;
-      this.cachedInterceptor = cachedInterceptor;
+      dart.initField(CachedInvocation, this, 'mangledName', mangledName);
+      dart.initField(CachedInvocation, this, 'jsFunction', jsFunction);
+      dart.initField(CachedInvocation, this, 'isIntercepted', isIntercepted);
+      dart.initField(CachedInvocation, 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$);
     }
   }
   class CachedCatchAllInvocation extends CachedInvocation {
     CachedCatchAllInvocation(name, jsFunction, isIntercepted, cachedInterceptor) {
-      this.info = new ReflectionInfo(jsFunction);
+      dart.initField(CachedCatchAllInvocation, 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 22 matching lines @@
         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$);
     }
   }
   class CachedNoSuchMethodInvocation extends core.Object {
     CachedNoSuchMethodInvocation(interceptor) {
-      this.interceptor = interceptor;
+      dart.initField(CachedNoSuchMethodInvocation, 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);
     }
   }
   class ReflectionInfo extends core.Object {
     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;
+      dart.initField(ReflectionInfo, this, 'jsFunction', jsFunction);
+      dart.initField(ReflectionInfo, this, 'data', data);
+      dart.initField(ReflectionInfo, this, 'isAccessor', isAccessor);
+      dart.initField(ReflectionInfo, this, 'requiredParameterCount', requiredParameterCount);
+      dart.initField(ReflectionInfo, this, 'optionalParameterCount', optionalParameterCount);
+      dart.initField(ReflectionInfo, this, 'areOptionalParametersNamed', areOptionalParametersNamed);
+      dart.initField(ReflectionInfo, this, 'functionType', functionType);
+      dart.initField(ReflectionInfo, 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 594 matching lines @@
   function throwAbstractClassInstantiationError(className) {
     throw new core.AbstractClassInstantiationError(dart.as(className, core.String));
   }
   let _argumentsExpr = Symbol('_argumentsExpr');
   let _expr = Symbol('_expr');
   let _method = Symbol('_method');
   let _receiver = Symbol('_receiver');
   let _pattern = Symbol('_pattern');
   class TypeErrorDecoder extends core.Object {
     TypeErrorDecoder(arguments$, argumentsExpr, expr, method, receiver, pattern) {
-      this[_arguments] = arguments$;
-      this[_argumentsExpr] = argumentsExpr;
-      this[_expr] = expr;
-      this[_method] = method;
-      this[_receiver] = receiver;
-      this[_pattern] = pattern;
+      dart.initField(TypeErrorDecoder, this, _arguments, arguments$);
+      dart.initField(TypeErrorDecoder, this, _argumentsExpr, argumentsExpr);
+      dart.initField(TypeErrorDecoder, this, _expr, expr);
+      dart.initField(TypeErrorDecoder, this, _method, method);
+      dart.initField(TypeErrorDecoder, this, _receiver, receiver);
+      dart.initField(TypeErrorDecoder, this, _pattern, pattern);
     }
     matchTypeError(message) {
       let match = new RegExp(this[_pattern]).exec(message);
       if (match == null)
         return null;
       let result = Object.create(null);
       if (this[_arguments] != -1) {
         result.arguments = match[this[_arguments] + 1];
       }
       if (this[_argumentsExpr] != -1) {
@@ skipping 681 matching lines @@
   // Function jsPropertyAccess: (dynamic, String) → dynamic
   function jsPropertyAccess(jsObject, property) {
     return jsObject[property];
   }
   // Function getFallThroughError: () → dynamic
   function getFallThroughError() {
     return new FallThroughErrorImplementation();
   }
   class Creates extends core.Object {
     Creates(types) {
-      this.types = types;
+      dart.initField(Creates, this, 'types', types);
     }
   }
   class Returns extends core.Object {
     Returns(types) {
-      this.types = types;
+      dart.initField(Returns, this, 'types', types);
     }
   }
   class JSName extends core.Object {
     JSName(name) {
-      this.name = name;
+      dart.initField(JSName, this, 'name', name);
     }
   }
   // Function boolConversionCheck: (dynamic) → dynamic
   function boolConversionCheck(value) {
     if (typeof value == 'boolean')
       return value;
     boolTypeCheck(value);
     dart.assert(value != null);
     return false;
   }
@@ skipping 253 matching lines @@
     }
   }
   dart.defineLazyClass(exports, {
     get JavaScriptIndexingBehavior() {
       class JavaScriptIndexingBehavior extends _interceptors.JSMutableIndexable {}
       return JavaScriptIndexingBehavior;
     }
   });
   class TypeErrorImplementation extends core.Error {
     TypeErrorImplementation(value, type) {
-      this.message = `type '${Primitives.objectTypeName(value)}' is not a subtype ` + `of type '${type}'`;
+      dart.initField(TypeErrorImplementation, this, 'message', `type '${Primitives.objectTypeName(value)}' is not a subtype ` + `of type '${type}'`);
       super.Error();
     }
     fromMessage(message) {
-      this.message = message;
+      dart.initField(TypeErrorImplementation, this, 'message', message);
       super.Error();
     }
     toString() {
       return this.message;
     }
   }
   TypeErrorImplementation[dart.implements] = () => [core.TypeError];
   dart.defineNamedConstructor(TypeErrorImplementation, 'fromMessage');
   class CastErrorImplementation extends core.Error {
     CastErrorImplementation(actualType, expectedType) {
-      this.message = `CastError: Casting value of type ${actualType} to` + ` incompatible type ${expectedType}`;
+      dart.initField(CastErrorImplementation, 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 18 matching lines @@
   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}`);
   }
   class RuntimeError extends core.Error {
     RuntimeError(message) {
-      this.message = message;
+      dart.initField(RuntimeError, this, 'message', message);
       super.Error();
     }
     toString() {
       return `RuntimeError: ${this.message}`;
     }
   }
   class DeferredNotLoadedError extends core.Error {
     DeferredNotLoadedError(libraryName) {
-      this.libraryName = libraryName;
+      dart.initField(DeferredNotLoadedError, 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 _isTest = Symbol('_isTest');
   let _extractFunctionTypeObjectFrom = Symbol('_extractFunctionTypeObjectFrom');
   let _asCheck = Symbol('_asCheck');
   let _check = Symbol('_check');
   let _assertCheck = Symbol('_assertCheck');
   class RuntimeFunctionType extends RuntimeType {
     RuntimeFunctionType(returnType, parameterTypes, optionalParameterTypes, namedParameters) {
-      this.returnType = returnType;
-      this.parameterTypes = parameterTypes;
-      this.optionalParameterTypes = optionalParameterTypes;
-      this.namedParameters = namedParameters;
+      dart.initField(RuntimeFunctionType, this, 'returnType', returnType);
+      dart.initField(RuntimeFunctionType, this, 'parameterTypes', parameterTypes);
+      dart.initField(RuntimeFunctionType, this, 'optionalParameterTypes', optionalParameterTypes);
+      dart.initField(RuntimeFunctionType, 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 197 matching lines @@
       }
       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.`);
     }
   }
   class RuntimeTypePlain extends RuntimeType {
     RuntimeTypePlain(name) {
-      this.name = name;
+      dart.initField(RuntimeTypePlain, this, 'name', 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;
     }
   }
   class RuntimeTypeGeneric extends RuntimeType {
     RuntimeTypeGeneric(name, arguments$, rti) {
-      this.name = name;
-      this.arguments = arguments$;
-      this.rti = rti;
+      dart.initField(RuntimeTypeGeneric, this, 'name', name);
+      dart.initField(RuntimeTypeGeneric, this, 'arguments', arguments$);
+      dart.initField(RuntimeTypeGeneric, 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 12 matching lines @@
   let _returnType = Symbol('_returnType');
   let _isVoid = Symbol('_isVoid');
   let _hasArguments = Symbol('_hasArguments');
   let _hasOptionalArguments = Symbol('_hasOptionalArguments');
   let _optionalArguments = Symbol('_optionalArguments');
   let _hasNamedArguments = Symbol('_hasNamedArguments');
   let _namedArguments = Symbol('_namedArguments');
   let _convert = Symbol('_convert');
   class FunctionTypeInfoDecoderRing extends core.Object {
     FunctionTypeInfoDecoderRing(typeData) {
-      this[_typeData] = typeData;
-      this[_cachedToString] = null;
+      dart.initField(FunctionTypeInfoDecoderRing, this, _typeData, typeData);
+      dart.initField(FunctionTypeInfoDecoderRing, this, _cachedToString, null);
     }
     get [_hasReturnType]() {
       return "ret" in this[_typeData];
     }
     get [_returnType]() {
       return this[_typeData].ret;
     }
     get [_isVoid]() {
       return !!this[_typeData].void;
     }
@@ skipping 453 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 = {}));