implement private members, fixes #74

test/codegen/expect/_js_helper/_js_helper.js

 var _js_helper;
 (function(exports) {
   'use strict';
   class _Patch extends dart.Object {
     _Patch() {
     }
   }
   let patch = new _Patch();
   class InternalMap extends dart.Object {
   }
@@ skipping 44 matching lines @@
   // Function traceHelper: (String) → void
   function traceHelper(method) {
     if (!this.cache) {
       this.cache = Object.create(null);
     }
     if (!this.cache[method]) {
       console.log(method);
       this.cache[method] = true;
     }
   }
+  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 dart.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;
+    JSInvocationMirror($_memberName, $_internalName, $_kind, $_arguments, $_namedArgumentNames) {
+      this[_memberName] = $_memberName;
+      this[_internalName] = $_internalName;
+      this[_kind] = $_kind;
+      this[_arguments] = $_arguments;
+      this[_namedArgumentNames] = $_namedArgumentNames;
+      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);
+      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(':').get(0);
       } else {
-        if (_js_names.mangledNames.get(this._internalName) === null) {
+        if (_js_names.mangledNames.get(this[_internalName]) === null) {
           core.print(`Warning: '${name}' is used reflectively but not in MirrorsUsed. ` + "This will break minified code.");
         }
       }
-      this._memberName = new _internal.Symbol.unvalidated(name);
-      return dart.as(this._memberName, core.Symbol);
+      this[_memberName] = new _internal.Symbol.unvalidated(name);
+      return dart.as(this[_memberName], core.Symbol);
     }
     get isMethod() {
-      return this._kind === METHOD;
+      return this[_kind] === METHOD;
     }
     get isGetter() {
-      return this._kind === GETTER;
+      return this[_kind] === GETTER;
     }
     get isSetter() {
-      return this._kind === SETTER;
+      return this[_kind] === SETTER;
     }
     get isAccessor() {
-      return this._kind !== METHOD;
+      return this[_kind] !== METHOD;
     }
     get positionalArguments() {
       if (this.isGetter)
         return /* Unimplemented const */new List.from([]);
-      let argumentCount = this._arguments.length - this._namedArgumentNames.length;
+      let argumentCount = this[_arguments].length - this[_namedArgumentNames].length;
       if (argumentCount === 0)
         return /* Unimplemented const */new List.from([]);
       let list = new List.from([]);
       for (let index = 0; index < argumentCount; index++) {
-        list.add(this._arguments.get(index));
+        list.add(this[_arguments].get(index));
       }
       return dart.as(makeLiteralListConst(list), core.List);
     }
     get namedArguments() {
       if (this.isAccessor)
         return dart.map();
-      let namedArgumentCount = this._namedArgumentNames.length;
-      let namedArgumentsStartIndex = this._arguments.length - namedArgumentCount;
+      let namedArgumentCount = this[_namedArgumentNames].length;
+      let namedArgumentsStartIndex = this[_arguments].length - namedArgumentCount;
       if (namedArgumentCount === 0)
         return dart.map();
       let map = new core.Map();
       for (let i = 0; i < namedArgumentCount; i++) {
-        map.set(new _internal.Symbol.unvalidated(dart.as(this._namedArgumentNames.get(i), core.String)), this._arguments.get(namedArgumentsStartIndex + i));
+        map.set(new _internal.Symbol.unvalidated(dart.as(this[_namedArgumentNames].get(i), core.String)), this[_arguments].get(namedArgumentsStartIndex + i));
       }
       return map;
     }
-    _getCachedInvocation(object) {
+    [_getCachedInvocation](object) {
       let interceptor = _interceptors.getInterceptor(object);
       let receiver = object;
-      let name = this._internalName;
-      let arguments = this._arguments;
+      let name = this[_internalName];
+      let arguments = this[_arguments];
       let interceptedNames = _foreign_helper.JS_EMBEDDED_GLOBAL('', dart.as(_js_embedded_names.INTERCEPTED_NAMES, core.String));
       let isIntercepted = Object.prototype.hasOwnProperty.call(interceptedNames, name);
       if (isIntercepted) {
         receiver = interceptor;
         if (object === interceptor) {
           interceptor = null;
         }
       } else {
         interceptor = null;
       }
@@ skipping 22 matching lines @@
         }
       } else {
         return new CachedNoSuchMethodInvocation(interceptor);
       }
     }
     static invokeFromMirror(invocation, victim) {
       let cached = invocation._getCachedInvocation(victim);
       if (dart.dload(cached, 'isNoSuchMethod')) {
         return dart.dinvoke(cached, 'invokeOn', victim, invocation);
       } else {
-        return dart.dinvoke(cached, 'invokeOn', victim, invocation._arguments);
+        return dart.dinvoke(cached, 'invokeOn', victim, invocation[_arguments]);
       }
     }
     static getCachedInvocation(invocation, victim) {
       return invocation._getCachedInvocation(victim);
     }
   }
   JSInvocationMirror.METHOD = 0;
   JSInvocationMirror.GETTER = 1;
   JSInvocationMirror.SETTER = 2;
   class CachedInvocation extends dart.Object {
@@ skipping 181 matching lines @@
   dart.defineNamedConstructor(ReflectionInfo, 'internal');
   ReflectionInfo.REQUIRED_PARAMETERS_INFO = 0;
   ReflectionInfo.OPTIONAL_PARAMETERS_INFO = 1;
   ReflectionInfo.FUNCTION_TYPE_INDEX = 2;
   ReflectionInfo.FIRST_DEFAULT_ARGUMENT = 3;
   // Function getMetadata: (int) → dynamic
   function getMetadata(index) {
     let metadata = _foreign_helper.JS_EMBEDDED_GLOBAL('', dart.as(_js_embedded_names.METADATA, core.String));
     return metadata[index];
   }
+  let _throwFormatException = Symbol('_throwFormatException');
+  let _fromCharCodeApply = Symbol('_fromCharCodeApply');
+  let _mangledNameMatchesType = Symbol('_mangledNameMatchesType');
+  let _typeName = Symbol('_typeName');
   class Primitives extends dart.Object {
     static initializeStatics(id) {
       mirrorFunctionCacheName = `_${id}`;
       mirrorInvokeCacheName = `_${id}`;
     }
     static objectHashCode(object) {
       let hash = dart.as(object.$identityHash, core.int);
       if (hash === null) {
         hash = Math.random() * 0x3fffffff | 0;
         object.$identityHash = hash;
       }
       return hash;
     }
-    static _throwFormatException(string) {
+    static [_throwFormatException](string) {
       throw new core.FormatException(string);
     }
     static parseInt(source, radix, handleError) {
       if (handleError === null)
         handleError = dart.as(_throwFormatException, dart.throw_("Unimplemented type (String) → int"));
       checkString(source);
       let match = /^\s*[+-]?((0x[a-f0-9]+)|(\d+)|([a-z0-9]+))\s*$/i.exec(source);
       let digitsIndex = 1;
       let hexIndex = 2;
       let decimalIndex = 3;
@@ skipping 104 matching lines @@
     static get isJsshell() {
       return typeof version == "function" && typeof system == "function";
     }
     static currentUri() {
       requiresPreamble();
       if (!!self.location) {
         return self.location.href;
       }
       return null;
     }
-    static _fromCharCodeApply(array) {
+    static [_fromCharCodeApply](array) {
       let result = "";
       let kMaxApply = 500;
       let end = array.length;
       for (let i = 0; i < end; i = kMaxApply) {
         let subarray = null;
         if (end <= kMaxApply) {
           subarray = array;
         } else {
           subarray = array.slice(i, i + kMaxApply < end ? i + kMaxApply : end);
         }
@@ skipping 227 matching lines @@
         } else {
           bad = true;
         }
       }).bind(this));
       if (bad) {
         return functionNoSuchMethod(function, positionalArguments, namedArguments);
       }
       positionalArguments.addAll(defaultArguments.values);
       return jsFunction.apply(function, positionalArguments);
     }
-    static _mangledNameMatchesType(mangledName, type) {
-      return mangledName == type._typeName;
+    static [_mangledNameMatchesType](mangledName, type) {
+      return mangledName == type[_typeName];
     }
     static identicalImplementation(a, b) {
       return a == null ? b == null : a === b;
     }
     static extractStackTrace(error) {
       return getTraceFromException(error.$thrownJsError);
     }
   }
   Primitives.mirrorFunctionCacheName = '$cachedFunction';
   Primitives.mirrorInvokeCacheName = '$cachedInvocation';
@@ skipping 93 matching lines @@
     return list;
   }
   // Function throwRuntimeError: (dynamic) → dynamic
   function throwRuntimeError(message) {
     throw new RuntimeError(message);
   }
   // Function throwAbstractClassInstantiationError: (dynamic) → dynamic
   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 dart.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;
+    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;
     }
     matchTypeError(message) {
-      let match = new RegExp(this._pattern).exec(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[_arguments] !== -1) {
+        result.arguments = match[this[_arguments] + 1];
       }
-      if (this._argumentsExpr !== -1) {
-        result.argumentsExpr = match[this._argumentsExpr + 1];
+      if (this[_argumentsExpr] !== -1) {
+        result.argumentsExpr = match[this[_argumentsExpr] + 1];
       }
-      if (this._expr !== -1) {
-        result.expr = match[this._expr + 1];
+      if (this[_expr] !== -1) {
+        result.expr = match[this[_expr] + 1];
       }
-      if (this._method !== -1) {
-        result.method = match[this._method + 1];
+      if (this[_method] !== -1) {
+        result.method = match[this[_method] + 1];
       }
-      if (this._receiver !== -1) {
-        result.receiver = match[this._receiver + 1];
+      if (this[_receiver] !== -1) {
+        result.receiver = match[this[_receiver] + 1];
       }
       return result;
     }
     static buildJavaScriptObject() {
       return {
         toString: function() {
           return "$receiver$";
         }
       };
     }
@@ skipping 114 matching lines @@
     get nullLiteralPropertyPattern() {
       return dart.as(extractPattern(provokePropertyErrorOnNull()), TypeErrorDecoder);
     },
     get undefinedPropertyPattern() {
       return dart.as(extractPattern(provokePropertyErrorOn(void 0)), TypeErrorDecoder);
     },
     get undefinedLiteralPropertyPattern() {
       return dart.as(extractPattern(provokePropertyErrorOnUndefined()), TypeErrorDecoder);
     }
   });
+  let _message = Symbol('_message');
   class NullError extends core.Error {
-    NullError(_message, match) {
-      this._message = _message;
-      this._method = dart.as(match === null ? null : match.method, core.String);
+    NullError($_message, match) {
+      this[_message] = $_message;
+      this[_method] = dart.as(match === null ? null : match.method, core.String);
       super.Error();
     }
     toString() {
-      if (this._method === null)
-        return `NullError: ${this._message}`;
-      return `NullError: Cannot call "${this._method}" on null`;
+      if (this[_method] === null)
+        return `NullError: ${this[_message]}`;
+      return `NullError: Cannot call "${this[_method]}" on null`;
     }
   }
   class JsNoSuchMethodError extends core.Error {
-    JsNoSuchMethodError(_message, match) {
-      this._message = _message;
-      this._method = dart.as(match === null ? null : match.method, core.String);
-      this._receiver = dart.as(match === null ? null : match.receiver, core.String);
+    JsNoSuchMethodError($_message, match) {
+      this[_message] = $_message;
+      this[_method] = dart.as(match === null ? null : match.method, core.String);
+      this[_receiver] = dart.as(match === null ? null : match.receiver, core.String);
       super.Error();
     }
     toString() {
-      if (this._method === null)
-        return `NoSuchMethodError: ${this._message}`;
-      if (this._receiver === null) {
-        return `NoSuchMethodError: Cannot call "${this._method}" (${this._message})`;
+      if (this[_method] === null)
+        return `NoSuchMethodError: ${this[_message]}`;
+      if (this[_receiver] === null) {
+        return `NoSuchMethodError: Cannot call "${this[_method]}" (${this[_message]})`;
       }
-      return `NoSuchMethodError: Cannot call "${this._method}" on "${this._receiver}" ` + `(${this._message})`;
+      return `NoSuchMethodError: Cannot call "${this[_method]}" on "${this[_receiver]}" ` + `(${this[_message]})`;
     }
   }
   class UnknownJsTypeError extends core.Error {
-    UnknownJsTypeError(_message) {
-      this._message = _message;
+    UnknownJsTypeError($_message) {
+      this[_message] = $_message;
       super.Error();
     }
     toString() {
-      return this._message.isEmpty ? 'Error' : `Error: ${this._message}`;
+      return this[_message].isEmpty ? 'Error' : `Error: ${this[_message]}`;
     }
   }
   // Function unwrapException: (dynamic) → dynamic
   function unwrapException(ex) {
     // Function saveStackTrace: (dynamic) → dynamic
     function saveStackTrace(error) {
       if (dart.is(error, core.Error)) {
         let thrownStackTrace = error.$thrownJsError;
         if (thrownStackTrace === null) {
           error.$thrownJsError = ex;
@@ skipping 57 matching lines @@
       if (dart.notNull(typeof message == string) && dart.notNull(dart.equals(message, 'too much recursion'))) {
         return new core.StackOverflowError();
       }
     }
     return ex;
   }
   // Function getTraceFromException: (dynamic) → StackTrace
   function getTraceFromException(exception) {
     return new _StackTrace(exception);
   }
+  let _exception = Symbol('_exception');
+  let _trace = Symbol('_trace');
   class _StackTrace extends dart.Object {
-    _StackTrace(_exception) {
-      this._exception = _exception;
-      this._trace = null;
+    _StackTrace($_exception) {
+      this[_exception] = $_exception;
+      this[_trace] = null;
     }
     toString() {
-      if (this._trace !== null)
-        return this._trace;
+      if (this[_trace] !== null)
+        return this[_trace];
       let trace = null;
-      if (typeof this._exception === "object") {
-        trace = dart.as(this._exception.stack, core.String);
+      if (typeof this[_exception] === "object") {
+        trace = dart.as(this[_exception].stack, core.String);
       }
-      return this._trace = trace === null ? '' : trace;
+      return this[_trace] = trace === null ? '' : trace;
     }
   }
   // Function objectHashCode: (dynamic) → int
   function objectHashCode(object) {
     if (dart.notNull(object === null) || dart.notNull(typeof object != 'object')) {
       return dart.as(dart.dload(object, 'hashCode'), core.int);
     } else {
       return Primitives.objectHashCode(object);
     }
   }
@@ skipping 254 matching lines @@
   Closure.REQUIRED_PARAMETER_INDEX = 3;
   Closure.OPTIONAL_PARAMETER_INDEX = 4;
   Closure.DEFAULT_ARGUMENTS_INDEX = 5;
   Closure.functionCounter = 0;
   // Function closureFromTearOff: (dynamic, dynamic, dynamic, dynamic, dynamic, dynamic) → dynamic
   function closureFromTearOff(receiver, functions, reflectionInfo, isStatic, jsArguments, name) {
     return Closure.fromTearOff(receiver, _interceptors.JSArray.markFixedList(dart.as(functions, core.List)), _interceptors.JSArray.markFixedList(dart.as(reflectionInfo, core.List)), !!isStatic, jsArguments, name);
   }
   class TearOffClosure extends Closure {
   }
+  let _self = Symbol('_self');
+  let _target = Symbol('_target');
+  let _name = Symbol('_name');
   class BoundClosure extends TearOffClosure {
-    BoundClosure(_self, _target, _receiver, _name) {
-      this._self = _self;
-      this._target = _target;
-      this._receiver = _receiver;
-      this._name = _name;
+    BoundClosure($_self, $_target, $_receiver, $_name) {
+      this[_self] = $_self;
+      this[_target] = $_target;
+      this[_receiver] = $_receiver;
+      this[_name] = $_name;
       super.TearOffClosure();
     }
     ['=='](other) {
       if (core.identical(this, other))
         return true;
       if (!dart.is(other, BoundClosure))
         return false;
-      return this._self === dart.dload(other, '_self') && this._target === dart.dload(other, '_target') && this._receiver === dart.dload(other, '_receiver');
+      return this[_self] === dart.dload(other, '_self') && this[_target] === dart.dload(other, '_target') && this[_receiver] === dart.dload(other, '_receiver');
     }
     get hashCode() {
       let receiverHashCode = null;
-      if (this._receiver === null) {
-        receiverHashCode = Primitives.objectHashCode(this._self);
-      } else if (!dart.equals(typeof this._receiver, 'object')) {
-        receiverHashCode = dart.as(dart.dload(this._receiver, 'hashCode'), core.int);
+      if (this[_receiver] === null) {
+        receiverHashCode = Primitives.objectHashCode(this[_self]);
+      } else if (!dart.equals(typeof this[_receiver], 'object')) {
+        receiverHashCode = dart.as(dart.dload(this[_receiver], 'hashCode'), core.int);
       } else {
-        receiverHashCode = Primitives.objectHashCode(this._receiver);
+        receiverHashCode = Primitives.objectHashCode(this[_receiver]);
       }
-      return receiverHashCode ^ Primitives.objectHashCode(this._target);
+      return receiverHashCode ^ Primitives.objectHashCode(this[_target]);
     }
     static selfOf(closure) {
-      return closure._self;
+      return closure[_self];
     }
     static targetOf(closure) {
-      return closure._target;
+      return closure[_target];
     }
     static receiverOf(closure) {
-      return closure._receiver;
+      return closure[_receiver];
     }
     static nameOf(closure) {
-      return closure._name;
+      return closure[_name];
     }
     static selfFieldName() {
       if (selfFieldNameCache === null) {
         selfFieldNameCache = computeFieldNamed('self');
       }
       return selfFieldNameCache;
     }
     static receiverFieldName() {
       if (receiverFieldNameCache === null) {
         receiverFieldNameCache = computeFieldNamed('receiver');
@@ skipping 372 matching lines @@
       super.Error();
     }
     toString() {
       return `Deferred library ${this.libraryName} was not loaded.`;
     }
   }
   class RuntimeType extends dart.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;
       super.RuntimeType();
     }
     get isVoid() {
       return dart.is(this.returnType, VoidRuntimeType);
     }
-    _isTest(expression) {
-      let functionTypeObject = this._extractFunctionTypeObjectFrom(expression);
+    [_isTest](expression) {
+      let functionTypeObject = this[_extractFunctionTypeObjectFrom](expression);
       return functionTypeObject === null ? false : isFunctionSubtype(functionTypeObject, this.toRti());
     }
-    _asCheck(expression) {
-      return this._check(expression, true);
+    [_asCheck](expression) {
+      return this[_check](expression, true);
     }
-    _assertCheck(expression) {
+    [_assertCheck](expression) {
       if (inAssert)
         return null;
       inAssert = true;
       try {
-        return this._check(expression, false);
+        return this[_check](expression, false);
       } finally {
         inAssert = false;
       }
     }
-    _check(expression, isCast) {
+    [_check](expression, isCast) {
       if (expression === null)
         return null;
-      if (this._isTest(expression))
+      if (this[_isTest](expression))
         return expression;
       let self = new FunctionTypeInfoDecoderRing(this.toRti()).toString();
       if (isCast) {
-        let functionTypeObject = this._extractFunctionTypeObjectFrom(expression);
+        let functionTypeObject = this[_extractFunctionTypeObjectFrom](expression);
         let pretty = null;
         if (functionTypeObject !== null) {
           pretty = new FunctionTypeInfoDecoderRing(functionTypeObject).toString();
         } else {
           pretty = Primitives.objectTypeName(expression);
         }
         throw new CastErrorImplementation(pretty, self);
       } else {
         throw new TypeErrorImplementation(expression, self);
       }
     }
-    _extractFunctionTypeObjectFrom(o) {
+    [_extractFunctionTypeObjectFrom](o) {
       let interceptor = _interceptors.getInterceptor(o);
       return _foreign_helper.JS_SIGNATURE_NAME() in interceptor ? interceptor[_foreign_helper.JS_SIGNATURE_NAME()]() : null;
     }
     toRti() {
       let result = {[_foreign_helper.JS_FUNCTION_TYPE_TAG()]: "dynafunc"};
       if (this.isVoid) {
         result[_foreign_helper.JS_FUNCTION_TYPE_VOID_RETURN_TAG()] = true;
       } else {
         if (!dart.is(this.returnType, DynamicRuntimeType)) {
           result[_foreign_helper.JS_FUNCTION_TYPE_RETURN_TYPE_TAG()] = this.returnType.toRti();
@@ skipping 188 matching lines @@
       }
       for (let argument of this.arguments) {
         result.push(argument.toRti());
       }
       return this.rti = result;
     }
     toString() {
       return `${this.name}<${this.arguments.join(", ")}>`;
     }
   }
+  let _typeData = Symbol('_typeData');
+  let _cachedToString = Symbol('_cachedToString');
+  let _hasReturnType = Symbol('_hasReturnType');
+  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 dart.Object {
-    FunctionTypeInfoDecoderRing(_typeData) {
-      this._typeData = _typeData;
-      this._cachedToString = null;
+    FunctionTypeInfoDecoderRing($_typeData) {
+      this[_typeData] = $_typeData;
+      this[_cachedToString] = null;
     }
-    get _hasReturnType() {
-      return "ret" in this._typeData;
+    get [_hasReturnType]() {
+      return "ret" in this[_typeData];
     }
-    get _returnType() {
-      return this._typeData.ret;
+    get [_returnType]() {
+      return this[_typeData].ret;
     }
-    get _isVoid() {
-      return !!this._typeData["void"];
+    get [_isVoid]() {
+      return !!this[_typeData]["void"];
     }
-    get _hasArguments() {
-      return "args" in this._typeData;
+    get [_hasArguments]() {
+      return "args" in this[_typeData];
     }
-    get _arguments() {
-      return dart.as(this._typeData.args, core.List);
+    get [_arguments]() {
+      return dart.as(this[_typeData].args, core.List);
     }
-    get _hasOptionalArguments() {
-      return "opt" in this._typeData;
+    get [_hasOptionalArguments]() {
+      return "opt" in this[_typeData];
     }
-    get _optionalArguments() {
-      return dart.as(this._typeData.opt, core.List);
+    get [_optionalArguments]() {
+      return dart.as(this[_typeData].opt, core.List);
     }
-    get _hasNamedArguments() {
-      return "named" in this._typeData;
+    get [_hasNamedArguments]() {
+      return "named" in this[_typeData];
     }
-    get _namedArguments() {
-      return this._typeData.named;
+    get [_namedArguments]() {
+      return this[_typeData].named;
     }
     toRuntimeType() {
       return new DynamicRuntimeType();
     }
-    _convert(type) {
+    [_convert](type) {
       let result = runtimeTypeToString(type);
       if (result !== null)
         return result;
       if ("func" in type) {
         return new FunctionTypeInfoDecoderRing(type).toString();
       } else {
         throw 'bad type';
       }
     }
     toString() {
-      if (this._cachedToString !== null)
-        return this._cachedToString;
+      if (this[_cachedToString] !== null)
+        return this[_cachedToString];
       let s = "(";
       let sep = '';
-      if (this._hasArguments) {
-        for (let argument of this._arguments) {
+      if (this[_hasArguments]) {
+        for (let argument of this[_arguments]) {
           s = sep;
-          s = this._convert(argument);
+          s = this[_convert](argument);
           sep = ', ';
         }
       }
-      if (this._hasOptionalArguments) {
+      if (this[_hasOptionalArguments]) {
         s = `${sep}[`;
         sep = '';
-        for (let argument of this._optionalArguments) {
+        for (let argument of this[_optionalArguments]) {
           s = sep;
-          s = this._convert(argument);
+          s = this[_convert](argument);
           sep = ', ';
         }
         s = ']';
       }
-      if (this._hasNamedArguments) {
+      if (this[_hasNamedArguments]) {
         s = `${sep}{`;
         sep = '';
-        for (let name of _js_names.extractKeys(this._namedArguments)) {
+        for (let name of _js_names.extractKeys(this[_namedArguments])) {
           s = sep;
           s = `${name}: `;
-          s = this._convert(this._namedArguments[name]);
+          s = this[_convert](this[_namedArguments][name]);
           sep = ', ';
         }
         s = '}';
       }
       s = ') -> ';
-      if (this._isVoid) {
+      if (this[_isVoid]) {
         s = 'void';
-      } else if (this._hasReturnType) {
-        s = this._convert(this._returnType);
+      } else if (this[_hasReturnType]) {
+        s = this[_convert](this[_returnType]);
       } else {
         s = 'dynamic';
       }
-      return this._cachedToString = `${s}`;
+      return this[_cachedToString] = `${s}`;
     }
   }
   class UnimplementedNoSuchMethodError extends core.Error {
-    UnimplementedNoSuchMethodError(_message) {
-      this._message = _message;
+    UnimplementedNoSuchMethodError($_message) {
+      this[_message] = $_message;
       super.Error();
     }
     toString() {
-      return `Unsupported operation: ${this._message}`;
+      return `Unsupported operation: ${this[_message]}`;
     }
   }
   // Function random64: () → int
   function random64() {
     let int32a = Math.random() * 0x100000000 >>> 0;
     let int32b = Math.random() * 0x100000000 >>> 0;
     return int32a + int32b * 4294967296;
   }
   // Function jsonEncodeNative: (String) → String
   function jsonEncodeNative(string) {
@@ skipping 106 matching lines @@
         completer.complete(null);
       }, 1), false);
       script.addEventListener("error", convertDartClosureToJS((event) => {
         completer.completeError(new async.DeferredLoadException(`Loading ${uri} failed.`));
       }, 1), false);
       document.body.appendChild(script);
       return completer.future;
     }));
   }
   class MainError extends core.Error {
-    MainError(_message) {
-      this._message = _message;
+    MainError($_message) {
+      this[_message] = $_message;
       super.Error();
     }
     toString() {
-      return `NoSuchMethodError: ${this._message}`;
+      return `NoSuchMethodError: ${this[_message]}`;
     }
   }
   // Function missingMain: () → void
   function missingMain() {
     throw new MainError("No top-level function named 'main'.");
   }
   // Function badMain: () → void
   function badMain() {
     throw new MainError("'main' is not a function.");
   }
@@ skipping 16 matching lines @@
   class IrRepresentation extends dart.Object {
     IrRepresentation(value) {
       this.value = value;
     }
   }
   class Native extends dart.Object {
     Native(name) {
       this.name = name;
     }
   }
+  let _throwUnmodifiable = Symbol('_throwUnmodifiable');
   let ConstantMap$ = dart.generic(function(K, V) {
     class ConstantMap extends dart.Object {
       ConstantMap$_() {
       }
       get isEmpty() {
         return this.length === 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       toString() {
         return collection.Maps.mapToString(this);
       }
-      _throwUnmodifiable() {
+      [_throwUnmodifiable]() {
         throw new core.UnsupportedError("Cannot modify unmodifiable Map");
       }
       set(key, val) {
-        return this._throwUnmodifiable();
+        return this[_throwUnmodifiable]();
       }
       putIfAbsent(key, ifAbsent) {
-        return dart.as(this._throwUnmodifiable(), V);
+        return dart.as(this[_throwUnmodifiable](), V);
       }
       remove(key) {
-        return dart.as(this._throwUnmodifiable(), V);
+        return dart.as(this[_throwUnmodifiable](), V);
       }
       clear() {
-        return this._throwUnmodifiable();
+        return this[_throwUnmodifiable]();
       }
       addAll(other) {
-        return this._throwUnmodifiable();
+        return this[_throwUnmodifiable]();
       }
     }
     dart.defineNamedConstructor(ConstantMap, '_');
     return ConstantMap;
   });
   let ConstantMap = ConstantMap$(dynamic, dynamic);
+  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) {
-      ConstantStringMap$_(length, _jsObject, _keys) {
+      ConstantStringMap$_(length, $_jsObject, $_keys) {
         this.length = length;
-        this._jsObject = _jsObject;
-        this._keys = _keys;
+        this[_jsObject] = $_jsObject;
+        this[_keys] = $_keys;
         super.ConstantMap$_();
       }
       containsValue(needle) {
         return this.values.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));
+        return jsHasOwnProperty(this[_jsObject], dart.as(key, core.String));
       }
       get(key) {
         if (!dart.notNull(this.containsKey(key)))
           return dart.as(null, V);
-        return dart.as(this._fetch(key), V);
+        return dart.as(this[_fetch](key), V);
       }
-      _fetch(key) {
-        return jsPropertyAccess(this._jsObject, dart.as(key, core.String));
+      [_fetch](key) {
+        return jsPropertyAccess(this[_jsObject], dart.as(key, core.String));
       }
       forEach(f) {
-        let keys = this._keys;
+        let keys = this[_keys];
         for (let i = 0; i['<'](dart.dload(keys, 'length')); i++) {
           let key = dart.dindex(keys, i);
-          f(dart.as(key, K), dart.as(this._fetch(key), V));
+          f(dart.as(key, K), dart.as(this[_fetch](key), V));
         }
       }
       get keys() {
         return new _ConstantMapKeyIterable(this);
       }
       get values() {
-        return new _internal.MappedIterable(this._keys, dart.as(((key) => this._fetch(key)).bind(this), dart.throw_("Unimplemented type (K) → V")));
+        return new _internal.MappedIterable(this[_keys], dart.as(((key) => this[_fetch](key)).bind(this), dart.throw_("Unimplemented type (K) → V")));
       }
     }
     dart.defineNamedConstructor(ConstantStringMap, '_');
     return ConstantStringMap;
   });
   let ConstantStringMap = ConstantStringMap$(dynamic, dynamic);
+  let _protoValue = Symbol('_protoValue');
   let ConstantProtoMap$ = dart.generic(function(K, V) {
     class ConstantProtoMap extends ConstantStringMap$(K, V) {
-      ConstantProtoMap$_(length, jsObject, keys, _protoValue) {
-        this._protoValue = _protoValue;
+      ConstantProtoMap$_(length, jsObject, keys, $_protoValue) {
+        this[_protoValue] = $_protoValue;
         super.ConstantStringMap$_(dart.as(length, core.int), jsObject, dart.as(keys, core.List$(K)));
       }
       containsKey(key) {
         if (!(typeof key == string))
           return false;
         if (dart.equals('__proto__', key))
           return true;
-        return jsHasOwnProperty(this._jsObject, dart.as(key, core.String));
+        return jsHasOwnProperty(this[_jsObject], dart.as(key, core.String));
       }
-      _fetch(key) {
-        return dart.equals('__proto__', key) ? this._protoValue : jsPropertyAccess(this._jsObject, dart.as(key, core.String));
+      [_fetch](key) {
+        return dart.equals('__proto__', key) ? this[_protoValue] : jsPropertyAccess(this[_jsObject], dart.as(key, core.String));
       }
     }
     dart.defineNamedConstructor(ConstantProtoMap, '_');
     return ConstantProtoMap;
   });
   let ConstantProtoMap = ConstantProtoMap$(dynamic, dynamic);
+  let _map = Symbol('_map');
   let _ConstantMapKeyIterable$ = dart.generic(function(K) {
     class _ConstantMapKeyIterable extends collection.IterableBase$(K) {
-      _ConstantMapKeyIterable(_map) {
-        this._map = _map;
+      _ConstantMapKeyIterable($_map) {
+        this[_map] = $_map;
         super.IterableBase();
       }
       get iterator() {
-        return this._map._keys.iterator;
+        return this[_map][_keys].iterator;
       }
       get length() {
-        return this._map._keys.length;
+        return this[_map][_keys].length;
       }
     }
     return _ConstantMapKeyIterable;
   });
   let _ConstantMapKeyIterable = _ConstantMapKeyIterable$(dynamic);
+  let _jsData = Symbol('_jsData');
+  let _getMap = Symbol('_getMap');
   let GeneralConstantMap$ = dart.generic(function(K, V) {
     class GeneralConstantMap extends ConstantMap$(K, V) {
-      GeneralConstantMap(_jsData) {
-        this._jsData = _jsData;
+      GeneralConstantMap($_jsData) {
+        this[_jsData] = $_jsData;
         super.ConstantMap$_();
       }
-      _getMap() {
+      [_getMap]() {
         if (!this.$map) {
           let backingMap = new collection.LinkedHashMap();
-          this.$map = fillLiteralMap(this._jsData, backingMap);
+          this.$map = fillLiteralMap(this[_jsData], backingMap);
         }
         return this.$map;
       }
       containsValue(needle) {
-        return this._getMap().containsValue(needle);
+        return this[_getMap]().containsValue(needle);
       }
       containsKey(key) {
-        return this._getMap().containsKey(key);
+        return this[_getMap]().containsKey(key);
       }
       get(key) {
-        return this._getMap().get(key);
+        return this[_getMap]().get(key);
       }
       forEach(f) {
-        this._getMap().forEach(f);
+        this[_getMap]().forEach(f);
       }
       get keys() {
-        return this._getMap().keys;
+        return this[_getMap]().keys;
       }
       get values() {
-        return this._getMap().values;
+        return this[_getMap]().values;
       }
       get length() {
-        return this._getMap().length;
+        return this[_getMap]().length;
       }
     }
     return GeneralConstantMap;
   });
   let GeneralConstantMap = GeneralConstantMap$(dynamic, dynamic);
   // Function contains: (String, String) → bool
   function contains(userAgent, name) {
     return userAgent.indexOf(name) !== -1;
   }
   // Function arrayLength: (List<dynamic>) → int
@@ skipping 244 matching lines @@
   }
   let _baseHooks = new _foreign_helper.JS_CONST('\nfunction() {\n  function typeNameInChrome(o) {\n    var constructor = o.constructor;\n    if (constructor) {\n      var name = constructor.name;\n      if (name) return name;\n    }\n    var s = Object.prototype.toString.call(o);\n    return s.substring(8, s.length - 1);\n  }\n  function getUnknownTag(object, tag) {\n    // This code really belongs in [getUnknownTagGenericBrowser] but having it\n    // here allows [getUnknownTag] to be tested on d8.\n    if (/^HTML[A-Z].*Element$/.test(tag)) {\n      // Check that it is not a simple JavaScript object.\n      var name = Object.prototype.toString.call(object);\n      if (name == "[object Object]") return null;\n      return "HTMLElement";\n    }\n  }\n  function getUnknownTagGenericBrowser(object, tag) {\n    if (self.HTMLElement && object instanceof HTMLElement) return "HTMLElement";\n    return getUnknownTag(object, tag);\n  }\n  function prototypeForTag(tag) {\n    if (typeof window == "undefined") return null;\n    if (typeof window[tag] == "undefined") return null;\n    var constructor = window[tag];\n    if (typeof constructor != "function") return null;\n    return constructor.prototype;\n  }\n  function discriminator(tag) { return null; }\n\n  var isBrowser = typeof navigator == "object";\n\n  return {\n    getTag: typeNameInChrome,\n    getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag,\n    prototypeForTag: prototypeForTag,\n    discriminator: discriminator };\n}');
   let _constructorNameFallback = new _foreign_helper.JS_CONST('\nfunction getTagFallback(o) {\n  var constructor = o.constructor;\n  if (typeof constructor == "function") {\n    var name = constructor.name;\n    // If the name is a non-empty string, we use that as the type name of this\n    // object.  There are various cases where that does not work, so we have to\n    // detect them and fall through to the toString() based implementation.\n\n    if (typeof name == "string" &&\n\n        // Sometimes the string is empty.  This test also catches minified\n        // shadow dom polyfil wrapper for Window on Firefox where the faked\n        // constructor name does not \'stick\'.  The shortest real DOM object\n        // names have three characters (e.g. URL, CSS).\n        name.length > 2 &&\n\n        // On Firefox we often get "Object" as the constructor name, even for\n        // more specialized DOM objects.\n        name !== "Object" &&\n\n        // This can happen in Opera.\n        name !== "Function.prototype") {\n      return name;\n    }\n  }\n  var s = Object.prototype.toString.call(o);\n  return s.substring(8, s.length - 1);\n}');
   let _fallbackConstructorHooksTransformerGenerator = new _foreign_helper.JS_CONST('\nfunction(getTagFallback) {\n  return function(hooks) {\n    // If we are not in a browser, assume we are in d8.\n    // TODO(sra): Recognize jsshell.\n    if (typeof navigator != "object") return hooks;\n\n    var ua = navigator.userAgent;\n    // TODO(antonm): remove a reference to DumpRenderTree.\n    if (ua.indexOf("DumpRenderTree") >= 0) return hooks;\n    if (ua.indexOf("Chrome") >= 0) {\n      // Confirm constructor name is usable for dispatch.\n      function confirm(p) {\n        return typeof window == "object" && window[p] && window[p].name == p;\n      }\n      if (confirm("Window") && confirm("HTMLElement")) return hooks;\n    }\n\n    hooks.getTag = getTagFallback;\n  };\n}');
   let _ieHooksTransformer = new _foreign_helper.JS_CONST('\nfunction(hooks) {\n  var userAgent = typeof navigator == "object" ? navigator.userAgent : "";\n  if (userAgent.indexOf("Trident/") == -1) return hooks;\n\n  var getTag = hooks.getTag;\n\n  var quickMap = {\n    "BeforeUnloadEvent": "Event",\n    "DataTransfer": "Clipboard",\n    "HTMLDDElement": "HTMLElement",\n    "HTMLDTElement": "HTMLElement",\n    "HTMLPhraseElement": "HTMLElement",\n    "Position": "Geoposition"\n  };\n\n  function getTagIE(o) {\n    var tag = getTag(o);\n    var newTag = quickMap[tag];\n    if (newTag) return newTag;\n    // Patches for types which report themselves as Objects.\n    if (tag == "Object") {\n      if (window.DataView && (o instanceof window.DataView)) return "DataView";\n    }\n    return tag;\n  }\n\n  function prototypeForTagIE(tag) {\n    var constructor = window[tag];\n    if (constructor == null) return null;\n    return constructor.prototype;\n  }\n\n  hooks.getTag = getTagIE;\n  hooks.prototypeForTag = prototypeForTagIE;\n}');
   let _fixDocumentHooksTransformer = new _foreign_helper.JS_CONST('\nfunction(hooks) {\n  var getTag = hooks.getTag;\n  var prototypeForTag = hooks.prototypeForTag;\n  function getTagFixed(o) {\n    var tag = getTag(o);\n    if (tag == "Document") {\n      // Some browsers and the polymer polyfill call both HTML and XML documents\n      // "Document", so we check for the xmlVersion property, which is the empty\n      // string on HTML documents. Since both dart:html classes Document and\n      // HtmlDocument share the same type, we must patch the instances and not\n      // the prototype.\n      if (!!o.xmlVersion) return "!Document";\n      return "!HTMLDocument";\n    }\n    return tag;\n  }\n\n  function prototypeForTagFixed(tag) {\n    if (tag == "Document") return null;  // Do not pre-patch Document.\n    return prototypeForTag(tag);\n  }\n\n  hooks.getTag = getTagFixed;\n  hooks.prototypeForTag = prototypeForTagFixed;\n}');
   let _firefoxHooksTransformer = new _foreign_helper.JS_CONST('\nfunction(hooks) {\n  var userAgent = typeof navigator == "object" ? navigator.userAgent : "";\n  if (userAgent.indexOf("Firefox") == -1) return hooks;\n\n  var getTag = hooks.getTag;\n\n  var quickMap = {\n    "BeforeUnloadEvent": "Event",\n    "DataTransfer": "Clipboard",\n    "GeoGeolocation": "Geolocation",\n    "Location": "!Location",               // Fixes issue 18151\n    "WorkerMessageEvent": "MessageEvent",\n    "XMLDocument": "!Document"};\n\n  function getTagFirefox(o) {\n    var tag = getTag(o);\n    return quickMap[tag] || tag;\n  }\n\n  hooks.getTag = getTagFirefox;\n}');
   let _operaHooksTransformer = new _foreign_helper.JS_CONST('\nfunction(hooks) { return hooks; }\n');
   let _safariHooksTransformer = new _foreign_helper.JS_CONST('\nfunction(hooks) { return hooks; }\n');
   let _dartExperimentalFixupGetTagHooksTransformer = new _foreign_helper.JS_CONST('\nfunction(hooks) {\n  if (typeof dartExperimentalFixupGetTag != "function") return hooks;\n  hooks.getTag = dartExperimentalFixupGetTag(hooks.getTag);\n}');
+  let _nativeRegExp = Symbol('_nativeRegExp');
   // Function regExpGetNative: (JSSyntaxRegExp) → dynamic
   function regExpGetNative(regexp) {
-    return regexp._nativeRegExp;
+    return regexp[_nativeRegExp];
   }
+  let _nativeGlobalVersion = Symbol('_nativeGlobalVersion');
   // Function regExpGetGlobalNative: (JSSyntaxRegExp) → dynamic
   function regExpGetGlobalNative(regexp) {
-    let nativeRegexp = regexp._nativeGlobalVersion;
+    let nativeRegexp = regexp[_nativeGlobalVersion];
     nativeRegexp.lastIndex = 0;
     return nativeRegexp;
   }
+  let _nativeAnchoredVersion = Symbol('_nativeAnchoredVersion');
   // Function regExpCaptureCount: (JSSyntaxRegExp) → int
   function regExpCaptureCount(regexp) {
-    let nativeAnchoredRegExp = regexp._nativeAnchoredVersion;
+    let nativeAnchoredRegExp = regexp[_nativeAnchoredVersion];
     let match = nativeAnchoredRegExp.exec('');
     return dart.as(dart.dbinary(dart.dload(match, 'length'), '-', 2), core.int);
   }
+  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 dart.Object {
     toString() {
       return `RegExp/${this.pattern}/`;
     }
     JSSyntaxRegExp(source, opt$) {
       let multiLine = opt$.multiLine === void 0 ? false : opt$.multiLine;
       let caseSensitive = opt$.caseSensitive === void 0 ? true : opt$.caseSensitive;
       this.pattern = source;
-      this._nativeRegExp = makeNative(source, multiLine, caseSensitive, false);
-      this._nativeGlobalRegExp = null;
-      this._nativeAnchoredRegExp = null;
+      this[_nativeRegExp] = makeNative(source, multiLine, caseSensitive, false);
+      this[_nativeGlobalRegExp] = null;
+      this[_nativeAnchoredRegExp] = null;
     }
-    get _nativeGlobalVersion() {
-      if (this._nativeGlobalRegExp !== null)
-        return this._nativeGlobalRegExp;
-      return this._nativeGlobalRegExp = makeNative(this.pattern, this._isMultiLine, this._isCaseSensitive, true);
+    get [_nativeGlobalVersion]() {
+      if (this[_nativeGlobalRegExp] !== null)
+        return this[_nativeGlobalRegExp];
+      return this[_nativeGlobalRegExp] = makeNative(this.pattern, this[_isMultiLine], this[_isCaseSensitive], true);
     }
-    get _nativeAnchoredVersion() {
-      if (this._nativeAnchoredRegExp !== null)
-        return this._nativeAnchoredRegExp;
-      return this._nativeAnchoredRegExp = makeNative(`${this.pattern}|()`, this._isMultiLine, this._isCaseSensitive, true);
+    get [_nativeAnchoredVersion]() {
+      if (this[_nativeAnchoredRegExp] !== null)
+        return this[_nativeAnchoredRegExp];
+      return this[_nativeAnchoredRegExp] = makeNative(`${this.pattern}|()`, this[_isMultiLine], this[_isCaseSensitive], true);
     }
-    get _isMultiLine() {
-      return this._nativeRegExp.multiline;
+    get [_isMultiLine]() {
+      return this[_nativeRegExp].multiline;
     }
-    get _isCaseSensitive() {
-      return !this._nativeRegExp.ignoreCase;
+    get [_isCaseSensitive]() {
+      return !this[_nativeRegExp].ignoreCase;
     }
     static makeNative(source, multiLine, caseSensitive, global) {
       checkString(source);
       let m = multiLine ? 'm' : '';
       let i = caseSensitive ? '' : 'i';
       let g = global ? 'g' : '';
       let regexp = function() {
         try {
           return new RegExp(source, m + i + g);
         } catch (e) {
           return e;
         }
 
       }();
       if (regexp instanceof RegExp)
         return regexp;
       let errorMessage = String(regexp);
       throw new core.FormatException(`Illegal RegExp pattern: ${source}, ${errorMessage}`);
     }
     firstMatch(string) {
-      let m = dart.as(this._nativeRegExp.exec(checkString(string)), core.List$(core.String));
+      let m = dart.as(this[_nativeRegExp].exec(checkString(string)), core.List$(core.String));
       if (m === null)
         return null;
       return new _MatchImplementation(this, m);
     }
     hasMatch(string) {
-      return this._nativeRegExp.test(checkString(string));
+      return this[_nativeRegExp].test(checkString(string));
     }
     stringMatch(string) {
       let match = this.firstMatch(string);
       if (match !== null)
         return match.group(0);
       return null;
     }
     allMatches(string, start) {
       if (start === void 0)
         start = 0;
       checkString(string);
       checkInt(start);
       if (dart.notNull(start < 0) || dart.notNull(start > string.length)) {
         throw new core.RangeError.range(start, 0, string.length);
       }
       return new _AllMatchesIterable(this, string, start);
     }
-    _execGlobal(string, start) {
-      let regexp = this._nativeGlobalVersion;
+    [_execGlobal](string, start) {
+      let regexp = this[_nativeGlobalVersion];
       regexp.lastIndex = start;
       let match = dart.as(regexp.exec(string), core.List);
       if (match === null)
         return null;
       return new _MatchImplementation(this, dart.as(match, core.List$(core.String)));
     }
-    _execAnchored(string, start) {
-      let regexp = this._nativeAnchoredVersion;
+    [_execAnchored](string, start) {
+      let regexp = this[_nativeAnchoredVersion];
       regexp.lastIndex = start;
       let match = dart.as(regexp.exec(string), core.List);
       if (match === null)
         return null;
       if (match.get(match.length - 1) !== null)
         return null;
       match.length = 1;
       return new _MatchImplementation(this, dart.as(match, core.List$(core.String)));
     }
     matchAsPrefix(string, start) {
       if (start === void 0)
         start = 0;
       if (dart.notNull(start < 0) || dart.notNull(start > string.length)) {
         throw new core.RangeError.range(start, 0, string.length);
       }
-      return this._execAnchored(string, start);
+      return this[_execAnchored](string, start);
     }
     get isMultiLine() {
-      return this._isMultiLine;
+      return this[_isMultiLine];
     }
     get isCaseSensitive() {
-      return this._isCaseSensitive;
+      return this[_isCaseSensitive];
     }
   }
+  let _match = Symbol('_match');
   class _MatchImplementation extends dart.Object {
-    _MatchImplementation(pattern, _match) {
+    _MatchImplementation(pattern, $_match) {
       this.pattern = pattern;
-      this._match = _match;
-      dart.assert(typeof this._match.input == string);
-      dart.assert(typeof this._match.index == number);
+      this[_match] = $_match;
+      dart.assert(typeof this[_match].input == string);
+      dart.assert(typeof this[_match].index == number);
     }
     get input() {
-      return this._match.input;
+      return this[_match].input;
     }
     get start() {
-      return this._match.index;
+      return this[_match].index;
     }
     get end() {
-      return this.start + this._match.get(0).length;
+      return this.start + this[_match].get(0).length;
     }
     group(index) {
-      return this._match.get(index);
+      return this[_match].get(index);
     }
     get(index) {
       return this.group(index);
     }
     get groupCount() {
-      return this._match.length - 1;
+      return this[_match].length - 1;
     }
     groups(groups) {
       let out = dart.as(new List.from([]), core.List$(core.String));
       for (let i of groups) {
         out.add(this.group(i));
       }
       return out;
     }
   }
+  let _re = Symbol('_re');
+  let _string = Symbol('_string');
+  let _start = Symbol('_start');
   class _AllMatchesIterable extends collection.IterableBase$(core.Match) {
-    _AllMatchesIterable(_re, _string, _start) {
-      this._re = _re;
-      this._string = _string;
-      this._start = _start;
+    _AllMatchesIterable($_re, $_string, $_start) {
+      this[_re] = $_re;
+      this[_string] = $_string;
+      this[_start] = $_start;
       super.IterableBase();
     }
     get iterator() {
-      return new _AllMatchesIterator(this._re, this._string, this._start);
+      return new _AllMatchesIterator(this[_re], this[_string], this[_start]);
     }
   }
+  let _regExp = Symbol('_regExp');
+  let _nextIndex = Symbol('_nextIndex');
+  let _current = Symbol('_current');
   class _AllMatchesIterator extends dart.Object {
-    _AllMatchesIterator(_regExp, _string, _nextIndex) {
-      this._regExp = _regExp;
-      this._string = _string;
-      this._nextIndex = _nextIndex;
-      this._current = null;
+    _AllMatchesIterator($_regExp, $_string, $_nextIndex) {
+      this[_regExp] = $_regExp;
+      this[_string] = $_string;
+      this[_nextIndex] = $_nextIndex;
+      this[_current] = null;
     }
     get current() {
-      return this._current;
+      return this[_current];
     }
     moveNext() {
-      if (this._string === null)
+      if (this[_string] === null)
         return false;
-      if (this._nextIndex <= this._string.length) {
-        let match = this._regExp._execGlobal(this._string, this._nextIndex);
+      if (this[_nextIndex] <= this[_string].length) {
+        let match = this[_regExp]._execGlobal(this[_string], this[_nextIndex]);
         if (match !== null) {
-          this._current = match;
+          this[_current] = match;
           let nextIndex = match.end;
           if (match.start === nextIndex) {
             nextIndex++;
           }
-          this._nextIndex = nextIndex;
+          this[_nextIndex] = nextIndex;
           return true;
         }
       }
-      this._current = null;
-      this._string = null;
+      this[_current] = null;
+      this[_string] = null;
       return false;
     }
   }
   // Function firstMatchAfter: (JSSyntaxRegExp, String, int) → Match
   function firstMatchAfter(regExp, string, start) {
     return regExp._execGlobal(string, start);
   }
   class StringMatch extends dart.Object {
     StringMatch(start, input, pattern) {
       this.start = start;
@@ skipping 194 matching lines @@
     }
   }
   // Function stringJoinUnchecked: (dynamic, dynamic) → dynamic
   function stringJoinUnchecked(array, separator) {
     return array.join(separator);
   }
   // Function createRuntimeType: (String) → Type
   function createRuntimeType(name) {
     return new TypeImpl(name);
   }
+  let _unmangledName = Symbol('_unmangledName');
   class TypeImpl extends dart.Object {
-    TypeImpl(_typeName) {
-      this._typeName = _typeName;
-      this._unmangledName = null;
+    TypeImpl($_typeName) {
+      this[_typeName] = $_typeName;
+      this[_unmangledName] = null;
     }
     toString() {
-      if (this._unmangledName !== null)
-        return this._unmangledName;
-      let unmangledName = _js_names.unmangleAllIdentifiersIfPreservedAnyways(this._typeName);
-      return this._unmangledName = unmangledName;
+      if (this[_unmangledName] !== null)
+        return this[_unmangledName];
+      let unmangledName = _js_names.unmangleAllIdentifiersIfPreservedAnyways(this[_typeName]);
+      return this[_unmangledName] = unmangledName;
     }
     get hashCode() {
-      return this._typeName.hashCode;
+      return this[_typeName].hashCode;
     }
     ['=='](other) {
-      return dart.notNull(dart.is(other, TypeImpl)) && dart.notNull(dart.equals(this._typeName, dart.dload(other, '_typeName')));
+      return dart.notNull(dart.is(other, TypeImpl)) && dart.notNull(dart.equals(this[_typeName], dart.dload(other, '_typeName')));
     }
   }
   class TypeVariable extends dart.Object {
     TypeVariable(owner, name, bound) {
       this.owner = owner;
       this.name = name;
       this.bound = bound;
     }
   }
   // Function getMangledTypeName: (TypeImpl) → dynamic
   function getMangledTypeName(type) {
-    return type._typeName;
+    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)
       target.$builtinTypeInfo = typeInfo;
     return target;
   }
   // Function getRuntimeTypeInfo: (Object) → dynamic
   function getRuntimeTypeInfo(target) {
@@ skipping 641 matching lines @@
   exports.getIndex = getIndex;
   exports.getLength = getLength;
   exports.isJsArray = isJsArray;
   exports.hasField = hasField;
   exports.hasNoField = hasNoField;
   exports.isJsFunction = isJsFunction;
   exports.isJsObject = isJsObject;
   exports.isIdentical = isIdentical;
   exports.isNotIdentical = isNotIdentical;
 })(_js_helper || (_js_helper = {}));