'extends Element'

sdk/lib/_internal/lib/interceptors.dart

 // 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;
+import 'dart:_foreign_helper' show JS, JS_EFFECT;
 
 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>();
@@ skipping 200 matching lines @@
   }
 }
 
 /**
  * If [JSInvocationMirror._invokeOn] is being used, this variable
  * contains a JavaScript array with the names of methods that are
  * intercepted.
  */
 var interceptedNames;
 
+
+/**
+ * A JavaScript array of 2N entries of adjacent slots containing a [Type]
+ * followed by an [Interceptor] class for the type.
+ *
+ * The value of this variable is set by the compiler and contains only types
+ * that are user extensions of native classes where the type occurs as a
+ * constant in the program.
+ */
+// TODO(sra): Mark this as initialized to a constant with unknown value.
+var mapTypeToInterceptor;
+
+findInterceptorConstructorForType(Type type) {
+  JS_EFFECT((_){ mapTypeToInterceptor = _; });
+  if (mapTypeToInterceptor == null) return null;
+  List map = JS('JSFixedArray', '#', mapTypeToInterceptor);
+  for (int i = 0; i + 1 < map.length; i += 2) {
+    if (type == map[i]) {
+      return map[i + 1];
+    }
+  }
+  return null;
+}
+
+findInterceptorForType(Type type) {
+  var constructor = findInterceptorConstructorForType(type);
+  if (constructor == null) return null;
+  return JS('', '#.prototype', constructor);
+}
+
 /**
  * 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
@@ skipping 143 matching lines @@
 }
 
 
 /**
  * Interceptor for unclassified JavaScript objects, typically objects with a
  * non-trivial prototype chain.
  */
 class UnknownJavaScriptObject extends JavaScriptObject {
   const UnknownJavaScriptObject();
 }