sdk/lib/_internal/lib/interceptors.dart - sdk.git - Git at Google

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 library _interceptors;

 import 'dart:collection';
 import 'dart:_collection-dev' hide Symbol;
 import "dart:_collection-dev" as _symbol_dev show Symbol;
 import 'dart:_js_helper' show allMatchesInStringUnchecked,
                               Null,
                               JSSyntaxRegExp,
                               Primitives,
                               checkNull,
                               checkNum,
                               checkString,
                               defineProperty,
                               getRuntimeType,
                               regExpGetNative,
                               stringContainsUnchecked,
                               stringLastIndexOfUnchecked,
                               stringReplaceAllFuncUnchecked,
                               stringReplaceAllUnchecked,
                               stringReplaceFirstUnchecked,
                               lookupDispatchRecord,
                               StringMatch,
                               firstMatchAfter;
 import 'dart:_foreign_helper' show JS;

 part 'js_array.dart';
 part 'js_number.dart';
 part 'js_string.dart';

 String _symbolToString(Symbol symbol) => _symbol_dev.Symbol.getName(symbol);

 _symbolMapToStringMap(Map<Symbol, dynamic> map) {
   if (map == null) return null;
   var result = new Map<String, dynamic>();
   map.forEach((Symbol key, value) {
     result[_symbolToString(key)] = value;
   });
   return result;
 }

 /**
  * Get the interceptor for [object]. Called by the compiler when it needs
  * to emit a call to an intercepted method, that is a method that is
  * defined in an interceptor class.
  */
 getInterceptor(object) {
   // This is a magic method: the compiler does specialization of it
   // depending on the uses of intercepted methods and instantiated
   // primitive types.
   // This method is recursive to prevent the type analyzer from thinking that
   // the method returns `null`.
   return getInterceptor(object);
 }

 /**
  * The name of the property used on native classes and `Object.prototype` to get
  * the interceptor for a native class instance.  The value is initialized on
  * isolate startup to ensure no two Dart programs in the same page use the same
  * property.
  */
 var dispatchPropertyName = null;

 getDispatchProperty(object) {
   // This is a magic method: the compiler replaces it with a runtime generated
   // function
   //
   //     function(object){return object._zzyzx;}
   //
   // where `_zzyzx` is replaced with the actual [dispatchPropertyName].
   //
   // The CSP compliant version replaces this function with one of a few
   // pre-compiled accessors, unless the pre-compiled versions are all in use,
   // when it falls back on this code.
   return JS('', '#[#]', object, dispatchPropertyName);
 }

 setDispatchProperty(object, value) {
   defineProperty(object, dispatchPropertyName, value);
 }

 makeDispatchRecord(interceptor, proto, extension, indexability) {
   // Dispatch records are stored in the prototype chain, and in some cases, on
   // instances.
   //
   // The record layout and field usage is designed to minimize the number of
   // operations on the common paths.
   //
   // [interceptor] is the interceptor - a holder of methods for the object,
   // i.e. the prototype of the interceptor class.
   //
   // [proto] is usually the prototype, used to check that the dispatch record
   // matches the object and is not the dispatch record of a superclass.  Other
   // values:
   //  - `false` for leaf classes that need no check.
   //  - `true` for Dart classes where the object is its own interceptor (unused)
   //  - a function used to continue matching.
   //
   // [extension] is used for irregular cases.
   //
   // [indexability] is used to cache whether or not the object
   // implements JavaScriptIndexingBehavior.
   //
   //     proto  interceptor extension action
   //     -----  ----------- --------- ------
   //     false  I                     use interceptor I
   //     true   -                     use object
   //     P      I                     if object's prototype is P, use I
   //     F      -           P         if object's prototype is P, call F

   // BUG(10903): Remove this hack. It is needed to avoid inlining this
   // method because inlining gives us multiple allocation points for
   // records which is bad because it leads to polymorphic access.
   if (false) return null;
   return JS('', '{i: #, p: #, e: #, x: #}',
             interceptor, proto, extension, indexability);
 }

 dispatchRecordInterceptor(record) => JS('', '#.i', record);
 dispatchRecordProto(record) => JS('', '#.p', record);
 dispatchRecordExtension(record) => JS('', '#.e', record);
 dispatchRecordIndexability(record) => JS('bool|Null', '#.x', record);

 /**
  * Returns the interceptor for a native class instance. Used by
  * [getInterceptor].
  */
 getNativeInterceptor(object) {
   var record = getDispatchProperty(object);

   if (record != null) {
     var proto = dispatchRecordProto(record);
     if (false == proto) return dispatchRecordInterceptor(record);
     if (true == proto) return object;
     var objectProto = JS('', 'Object.getPrototypeOf(#)', object);
     if (JS('bool', '# === #', proto, objectProto)) {
       return dispatchRecordInterceptor(record);
     }

     var extension = dispatchRecordExtension(record);
     if (JS('bool', '# === #', extension, objectProto)) {
       // The extension handler will do any required patching.  A typical use
       // case is where one native class represents two Dart classes.  The
       // extension method will inspect the native object instance to determine
       // its class and patch the instance.  Needed to fix dartbug.com/9654.
       return JS('', '(#)(#, #)', proto, object, record);
     }
   }

   record = lookupDispatchRecord(object);
   if (record == null) {
     return const JSUnknown();
   }
   setDispatchProperty(JS('', 'Object.getPrototypeOf(#)', object), record);
   return getNativeInterceptor(object);
 }

 /**
  * Initializes the [getDispatchProperty] function and [dispatchPropertyName]
  * variable.  Each isolate running in a web page needs a different
  * [dispatchPropertyName], so if a given dispatch property name is in use by
  * some other program loaded into the web page, another name is chosen.
  *
  * The non-CSP version is called like this:
  *
  *     initializeDispatchProperty(
  *         function(x){$.getDispatchProperty=x},
  *         '_f4$Dxv7S',
  *         $.Interceptor);
  *
  * The [getDispatchProperty] function is generated from the chosen name of the
  * property.
  *
  * The CSP version can't create functions via `new Function(...)`, so it is
  * given a fixed set of functions to choose from.  If all the property names in
  * the fixed set of functions are in use, it falls back on the definition of
  * [getDispatchProperty] above.
  *
  *     initializeDispatchPropertyCSP(
  *         function(x){$.getDispatchProperty=x},
  *         [function(a){return a._f4$Dxv7S},
  *          function(a){return a._Q2zpL9iY}],
  *         $.Interceptor);
  */
 void initializeDispatchProperty(
     setGetDispatchPropertyFn, rootProperty, jsObjectInterceptor) {
   // We must be extremely careful to avoid any language feature that needs an
   // interceptor.  Avoid type annotations since they might generate type checks.
   var objectProto = JS('=Object', 'Object.prototype');
   for (var i = 0; ; i = JS('int', '# + 1', i)) {
     var property = rootProperty;
     if (JS('bool', '# > 0', i)) {
       property = JS('String', '# + "_" + #', rootProperty, i);
     }
     if (JS('bool', 'typeof #[#] === "undefined"', objectProto, property)) {
       dispatchPropertyName = property;
       var getter = JS('', 'new Function("a", "return a." + #)', property);
       JS('void', '#(#)', setGetDispatchPropertyFn, getter);
       setDispatchProperty(
           objectProto,
           makeDispatchRecord(jsObjectInterceptor, objectProto, null, null));
       return;
     }
   }
 }

 void initializeDispatchPropertyCSP(
     setGetDispatchPropertyFn, getterFunctions, jsObjectInterceptor) {
   // We must be extremely careful to avoid any language feature that needs an
   // interceptor.  Avoid type annotations since they might generate type checks.
   var objectProto = JS('=Object', 'Object.prototype');
   var property = null;
   var getter = null;
   var rootProperty = null;
   for (var i = 0; ; i = JS('int', '# + 1', i)) {
     if (JS('bool', '# < #.length', i, getterFunctions)) {
       getter = JS('', '#[#]', getterFunctions, i);
       var fnText = JS('String', '"" + #', getter);
       property =
           JS('String', '#.match(#)[1]', fnText, JS('', r'/\.([^;}]*)/'));
       rootProperty = property;
     } else {
       getter = null;
       property = JS('String', '# + "_" + #', rootProperty, i);
     }
     if (JS('bool', 'typeof #[#] === "undefined"', objectProto, property)) {
       dispatchPropertyName = property;
       if (!identical(getter, null)) {
         JS('void', '#(#)', setGetDispatchPropertyFn, getter);
       }
       setDispatchProperty(
           objectProto,
           makeDispatchRecord(jsObjectInterceptor, objectProto, null, null));
       return;
     }
   }
 }

 /**
  * If [JSInvocationMirror._invokeOn] is being used, this variable
  * contains a JavaScript array with the names of methods that are
  * intercepted.
  */
 var interceptedNames;

 /**
  * The base interceptor class.
  *
  * The code `r.foo(a)` is compiled to `getInterceptor(r).foo$1(r, a)`.  The
  * value returned by [getInterceptor] holds the methods separately from the
  * state of the instance.  The compiler converts the methods on an interceptor
  * to take the Dart `this` argument as an explicit `receiver` argument.  The
  * JavaScript `this` parameter is bound to the interceptor.
  *
  * In order to have uniform call sites, if a method is defined on an
  * interceptor, methods of that name on plain unintercepted classes also use the
  * interceptor calling convention.  The plain classes are _self-interceptors_,
  * and for them, `getInterceptor(r)` returns `r`.  Methods on plain
  * unintercepted classes have a redundant `receiver` argument and should ignore
  * it in favour of `this`.
  *
  * In the case of mixins, a method may be placed on both an intercepted class
  * and an unintercepted class.  In this case, the method must use the `receiver`
  * parameter.
  *
  *
  * There are various optimizations of the general call pattern.
  *
  * When the interceptor can be statically determined, it can be used directly:
  *
  *     CONSTANT_INTERCEPTOR.foo$1(r, a)
  *
  * If there are only a few classes, [getInterceptor] can be specialized with a
  * more efficient dispatch:
  *
  *     getInterceptor$specialized(r).foo$1(r, a)
  *
  * If it can be determined that the receiver is an unintercepted class, it can
  * be called directly:
  *
  *     r.foo$1(r, a)
  *
  * If, further, it is known that the call site cannot call a foo that is
  * mixed-in to a native class, then it is known that the explicit receiver is
  * ignored, and space-saving dummy value can be passed instead:
  *
  *     r.foo$1(0, a)
  *
  * This class defines implementations of *all* methods on [Object] so no
  * interceptor inherits an implementation from [Object].  This enables the
  * implementations on Object to ignore the explicit receiver argument, which
  * allows dummy receiver optimization.
  */
 abstract class Interceptor {
   const Interceptor();

   bool operator ==(other) => identical(this, other);

   int get hashCode => Primitives.objectHashCode(this);

   String toString() => Primitives.objectToString(this);

   dynamic noSuchMethod(Invocation invocation) {
     throw new NoSuchMethodError(
         this,
         _symbolToString(invocation.memberName),
         invocation.positionalArguments,
         _symbolMapToStringMap(invocation.namedArguments));
   }

   Type get runtimeType => getRuntimeType(this);
 }

 /**
  * The interceptor class for [bool].
  */
 class JSBool extends Interceptor implements bool {
   const JSBool();

   // Note: if you change this, also change the function [S].
   String toString() => JS('String', r'String(#)', this);

   // The values here are SMIs, co-prime and differ about half of the bit
   // positions, including the low bit, so they are different mod 2^k.
   int get hashCode => this ? (2 * 3 * 23 * 3761) : (269 * 811);

   Type get runtimeType => bool;
 }

 /**
  * The interceptor class for [Null].
  *
  * This class defines implementations for *all* methods on [Object] since the
  * the methods on Object assume the receiver is non-null.  This means that
  * JSNull will always be in the interceptor set for methods defined on Object.
  */
 class JSNull extends Interceptor implements Null {
   const JSNull();

   bool operator ==(other) => identical(null, other);

   // Note: if you change this, also change the function [S].
   String toString() => 'null';

   int get hashCode => 0;

   Type get runtimeType => Null;
 }

 class JSUnknown extends Interceptor {
   const JSUnknown();

   String toString() => JS('String', 'String(#)', this);

   int get hashCode => 0;

   Type get runtimeType => null;
 }

 /**
  * The supertype for JSString and JSArray. Used by the backend as to
  * have a type mask that contains the objects that we can use the
  * native JS [] operator and length on.
  */
 abstract class JSIndexable {
   int get length;
   operator[](int index);
 }

 /**
  * The supertype for JSMutableArray and
  * JavaScriptIndexingBehavior. Used by the backend to have a type mask
  * that contains the objects we can use the JS []= operator on.
  */
 abstract class JSMutableIndexable extends JSIndexable {
   operator[]=(int index, var value);
 }
	// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	library _interceptors;

	import 'dart:collection';
	import 'dart:_collection-dev' hide Symbol;
	import "dart:_collection-dev" as _symbol_dev show Symbol;
	import 'dart:_js_helper' show allMatchesInStringUnchecked,
	Null,
	JSSyntaxRegExp,
	Primitives,
	checkNull,
	checkNum,
	checkString,
	defineProperty,
	getRuntimeType,
	regExpGetNative,
	stringContainsUnchecked,
	stringLastIndexOfUnchecked,
	stringReplaceAllFuncUnchecked,
	stringReplaceAllUnchecked,
	stringReplaceFirstUnchecked,
	lookupDispatchRecord,
	StringMatch,
	firstMatchAfter;
	import 'dart:_foreign_helper' show JS;

	part 'js_array.dart';
	part 'js_number.dart';
	part 'js_string.dart';

	String _symbolToString(Symbol symbol) => _symbol_dev.Symbol.getName(symbol);

	_symbolMapToStringMap(Map<Symbol, dynamic> map) {
	if (map == null) return null;
	var result = new Map<String, dynamic>();
	map.forEach((Symbol key, value) {
	result[_symbolToString(key)] = value;
	});
	return result;
	}

	/**
	* Get the interceptor for [object]. Called by the compiler when it needs
	* to emit a call to an intercepted method, that is a method that is
	* defined in an interceptor class.
	*/
	getInterceptor(object) {
	// This is a magic method: the compiler does specialization of it
	// depending on the uses of intercepted methods and instantiated
	// primitive types.
	// This method is recursive to prevent the type analyzer from thinking that
	// the method returns `null`.
	return getInterceptor(object);
	}

	/**
	* The name of the property used on native classes and `Object.prototype` to get
	* the interceptor for a native class instance. The value is initialized on
	* isolate startup to ensure no two Dart programs in the same page use the same
	* property.
	*/
	var dispatchPropertyName = null;

	getDispatchProperty(object) {
	// This is a magic method: the compiler replaces it with a runtime generated
	// function
	//
	// function(object){return object._zzyzx;}
	//
	// where `_zzyzx` is replaced with the actual [dispatchPropertyName].
	//
	// The CSP compliant version replaces this function with one of a few
	// pre-compiled accessors, unless the pre-compiled versions are all in use,
	// when it falls back on this code.
	return JS('', '#[#]', object, dispatchPropertyName);
	}

	setDispatchProperty(object, value) {
	defineProperty(object, dispatchPropertyName, value);
	}

	makeDispatchRecord(interceptor, proto, extension, indexability) {
	// Dispatch records are stored in the prototype chain, and in some cases, on
	// instances.
	//
	// The record layout and field usage is designed to minimize the number of
	// operations on the common paths.
	//
	// [interceptor] is the interceptor - a holder of methods for the object,
	// i.e. the prototype of the interceptor class.
	//
	// [proto] is usually the prototype, used to check that the dispatch record
	// matches the object and is not the dispatch record of a superclass. Other
	// values:
	// - `false` for leaf classes that need no check.
	// - `true` for Dart classes where the object is its own interceptor (unused)
	// - a function used to continue matching.
	//
	// [extension] is used for irregular cases.
	//
	// [indexability] is used to cache whether or not the object
	// implements JavaScriptIndexingBehavior.
	//
	// proto interceptor extension action
	// ----- ----------- --------- ------
	// false I use interceptor I
	// true - use object
	// P I if object's prototype is P, use I
	// F - P if object's prototype is P, call F

	// BUG(10903): Remove this hack. It is needed to avoid inlining this
	// method because inlining gives us multiple allocation points for
	// records which is bad because it leads to polymorphic access.
	if (false) return null;
	return JS('', '{i: #, p: #, e: #, x: #}',
	interceptor, proto, extension, indexability);
	}

	dispatchRecordInterceptor(record) => JS('', '#.i', record);
	dispatchRecordProto(record) => JS('', '#.p', record);
	dispatchRecordExtension(record) => JS('', '#.e', record);
	dispatchRecordIndexability(record) => JS('bool\|Null', '#.x', record);

	/**
	* Returns the interceptor for a native class instance. Used by
	* [getInterceptor].
	*/
	getNativeInterceptor(object) {
	var record = getDispatchProperty(object);

	if (record != null) {
	var proto = dispatchRecordProto(record);
	if (false == proto) return dispatchRecordInterceptor(record);
	if (true == proto) return object;
	var objectProto = JS('', 'Object.getPrototypeOf(#)', object);
	if (JS('bool', '# === #', proto, objectProto)) {
	return dispatchRecordInterceptor(record);
	}

	var extension = dispatchRecordExtension(record);
	if (JS('bool', '# === #', extension, objectProto)) {
	// The extension handler will do any required patching. A typical use
	// case is where one native class represents two Dart classes. The
	// extension method will inspect the native object instance to determine
	// its class and patch the instance. Needed to fix dartbug.com/9654.
	return JS('', '(#)(#, #)', proto, object, record);
	}
	}

	record = lookupDispatchRecord(object);
	if (record == null) {
	return const JSUnknown();
	}
	setDispatchProperty(JS('', 'Object.getPrototypeOf(#)', object), record);
	return getNativeInterceptor(object);
	}

	/**
	* Initializes the [getDispatchProperty] function and [dispatchPropertyName]
	* variable. Each isolate running in a web page needs a different
	* [dispatchPropertyName], so if a given dispatch property name is in use by
	* some other program loaded into the web page, another name is chosen.
	*
	* The non-CSP version is called like this:
	*
	* initializeDispatchProperty(
	* function(x){$.getDispatchProperty=x},
	* '_f4$Dxv7S',
	* $.Interceptor);
	*
	* The [getDispatchProperty] function is generated from the chosen name of the
	* property.
	*
	* The CSP version can't create functions via `new Function(...)`, so it is
	* given a fixed set of functions to choose from. If all the property names in
	* the fixed set of functions are in use, it falls back on the definition of
	* [getDispatchProperty] above.
	*
	* initializeDispatchPropertyCSP(
	* function(x){$.getDispatchProperty=x},
	* [function(a){return a._f4$Dxv7S},
	* function(a){return a._Q2zpL9iY}],
	* $.Interceptor);
	*/
	void initializeDispatchProperty(
	setGetDispatchPropertyFn, rootProperty, jsObjectInterceptor) {
	// We must be extremely careful to avoid any language feature that needs an
	// interceptor. Avoid type annotations since they might generate type checks.
	var objectProto = JS('=Object', 'Object.prototype');
	for (var i = 0; ; i = JS('int', '# + 1', i)) {
	var property = rootProperty;
	if (JS('bool', '# > 0', i)) {
	property = JS('String', '# + "_" + #', rootProperty, i);
	}
	if (JS('bool', 'typeof #[#] === "undefined"', objectProto, property)) {
	dispatchPropertyName = property;
	var getter = JS('', 'new Function("a", "return a." + #)', property);
	JS('void', '#(#)', setGetDispatchPropertyFn, getter);
	setDispatchProperty(
	objectProto,
	makeDispatchRecord(jsObjectInterceptor, objectProto, null, null));
	return;
	}
	}
	}

	void initializeDispatchPropertyCSP(
	setGetDispatchPropertyFn, getterFunctions, jsObjectInterceptor) {
	// We must be extremely careful to avoid any language feature that needs an
	// interceptor. Avoid type annotations since they might generate type checks.
	var objectProto = JS('=Object', 'Object.prototype');
	var property = null;
	var getter = null;
	var rootProperty = null;
	for (var i = 0; ; i = JS('int', '# + 1', i)) {
	if (JS('bool', '# < #.length', i, getterFunctions)) {
	getter = JS('', '#[#]', getterFunctions, i);
	var fnText = JS('String', '"" + #', getter);
	property =
	JS('String', '#.match(#)[1]', fnText, JS('', r'/\.([^;}]*)/'));
	rootProperty = property;
	} else {
	getter = null;
	property = JS('String', '# + "_" + #', rootProperty, i);
	}
	if (JS('bool', 'typeof #[#] === "undefined"', objectProto, property)) {
	dispatchPropertyName = property;
	if (!identical(getter, null)) {
	JS('void', '#(#)', setGetDispatchPropertyFn, getter);
	}
	setDispatchProperty(
	objectProto,
	makeDispatchRecord(jsObjectInterceptor, objectProto, null, null));
	return;
	}
	}
	}

	/**
	* If [JSInvocationMirror._invokeOn] is being used, this variable
	* contains a JavaScript array with the names of methods that are
	* intercepted.
	*/
	var interceptedNames;

	/**
	* The base interceptor class.
	*
	* The code `r.foo(a)` is compiled to `getInterceptor(r).foo$1(r, a)`. The
	* value returned by [getInterceptor] holds the methods separately from the
	* state of the instance. The compiler converts the methods on an interceptor
	* to take the Dart `this` argument as an explicit `receiver` argument. The
	* JavaScript `this` parameter is bound to the interceptor.
	*
	* In order to have uniform call sites, if a method is defined on an
	* interceptor, methods of that name on plain unintercepted classes also use the
	* interceptor calling convention. The plain classes are _self-interceptors_,
	* and for them, `getInterceptor(r)` returns `r`. Methods on plain
	* unintercepted classes have a redundant `receiver` argument and should ignore
	* it in favour of `this`.
	*
	* In the case of mixins, a method may be placed on both an intercepted class
	* and an unintercepted class. In this case, the method must use the `receiver`
	* parameter.
	*
	*
	* There are various optimizations of the general call pattern.
	*
	* When the interceptor can be statically determined, it can be used directly:
	*
	* CONSTANT_INTERCEPTOR.foo$1(r, a)
	*
	* If there are only a few classes, [getInterceptor] can be specialized with a
	* more efficient dispatch:
	*
	* getInterceptor$specialized(r).foo$1(r, a)
	*
	* If it can be determined that the receiver is an unintercepted class, it can
	* be called directly:
	*
	* r.foo$1(r, a)
	*
	* If, further, it is known that the call site cannot call a foo that is
	* mixed-in to a native class, then it is known that the explicit receiver is
	* ignored, and space-saving dummy value can be passed instead:
	*
	* r.foo$1(0, a)
	*
	* This class defines implementations of all methods on [Object] so no
	* interceptor inherits an implementation from [Object]. This enables the
	* implementations on Object to ignore the explicit receiver argument, which
	* allows dummy receiver optimization.
	*/
	abstract class Interceptor {
	const Interceptor();

	bool operator ==(other) => identical(this, other);

	int get hashCode => Primitives.objectHashCode(this);

	String toString() => Primitives.objectToString(this);

	dynamic noSuchMethod(Invocation invocation) {
	throw new NoSuchMethodError(
	this,
	_symbolToString(invocation.memberName),
	invocation.positionalArguments,
	_symbolMapToStringMap(invocation.namedArguments));
	}

	Type get runtimeType => getRuntimeType(this);
	}

	/**
	* The interceptor class for [bool].
	*/
	class JSBool extends Interceptor implements bool {
	const JSBool();

	// Note: if you change this, also change the function [S].
	String toString() => JS('String', r'String(#)', this);

	// The values here are SMIs, co-prime and differ about half of the bit
	// positions, including the low bit, so they are different mod 2^k.
	int get hashCode => this ? (2 * 3 * 23 * 3761) : (269 * 811);

	Type get runtimeType => bool;
	}

	/**
	* The interceptor class for [Null].
	*
	* This class defines implementations for all methods on [Object] since the
	* the methods on Object assume the receiver is non-null. This means that
	* JSNull will always be in the interceptor set for methods defined on Object.
	*/
	class JSNull extends Interceptor implements Null {
	const JSNull();

	bool operator ==(other) => identical(null, other);

	// Note: if you change this, also change the function [S].
	String toString() => 'null';

	int get hashCode => 0;

	Type get runtimeType => Null;
	}

	class JSUnknown extends Interceptor {
	const JSUnknown();

	String toString() => JS('String', 'String(#)', this);

	int get hashCode => 0;

	Type get runtimeType => null;
	}

	/**
	* The supertype for JSString and JSArray. Used by the backend as to
	* have a type mask that contains the objects that we can use the
	* native JS [] operator and length on.
	*/
	abstract class JSIndexable {
	int get length;
	operator[](int index);
	}

	/**
	* The supertype for JSMutableArray and
	* JavaScriptIndexingBehavior. Used by the backend to have a type mask
	* that contains the objects we can use the JS []= operator on.
	*/
	abstract class JSMutableIndexable extends JSIndexable {
	operator[]=(int index, var value);
	}