Use interceptors to handle runtime types.

dart/sdk/lib/_internal/lib/js_mirrors.dart

 // Copyright (c) 2013, 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 dart._js_mirrors;
 
 import 'dart:async';
 import 'dart:collection' show UnmodifiableListView;
 import 'dart:mirrors';
 
@@ skipping 416 matching lines @@
   if (classMirrors == null) classMirrors = JsCache.allocate();
   var mirror = JsCache.fetch(classMirrors, mangledName);
   if (mirror != null) return mirror;
   disableTreeShaking();
   var constructorOrInterceptor =
       Primitives.getConstructorOrInterceptor(mangledName);
   if (constructorOrInterceptor == null) {
     int index = JS('int|Null', 'init.functionAliases[#]', mangledName);
     if (index != null) {
       mirror = new JsTypedefMirror(
-          symbol, mangledName, JS('=Object', 'init.metadata[#]', index));
+          symbol, mangledName, JS('', 'init.metadata[#]', index));
       JsCache.update(classMirrors, mangledName, mirror);
       return mirror;
     }
     // Probably an intercepted class.
     // TODO(ahe): How to handle intercepted classes?
     throw new UnsupportedError('Cannot find class for: ${n(symbol)}');
   }
   var constructor = (constructorOrInterceptor is Interceptor)
       ? JS('', '#.constructor', constructorOrInterceptor)
       : constructorOrInterceptor;
@@ skipping 997 matching lines @@
 }
 
 class JsFunctionTypeMirror implements FunctionTypeMirror {
   final _typeData;
   String _cachedToString;
   TypeMirror _cachedReturnType;
   UnmodifiableListView<ParameterMirror> _cachedParameters;
 
   JsFunctionTypeMirror(this._typeData);
 
-  bool get _hasReturnType => JS('bool', '"ret" in #', _typeData);
-  get _returnType => JS('', '#.ret', _typeData);
-
-  bool get _isVoid => JS('bool', '!!#.void', _typeData);
-
-  bool get _hasArguments => JS('bool', '"args" in #', _typeData);
-  List get _arguments => JS('JSExtendableArray', '#.args', _typeData);
-
-  bool get _hasOptionalArguments => JS('bool', '"opt" in #', _typeData);
-  List get _optionalArguments => JS('JSExtendableArray', '#.opt', _typeData);
-
-  bool get _hasNamedArguments => JS('bool', '"named" in #', _typeData);
-  get _namedArguments => JS('=Object', '#.named', _typeData);
-
   TypeMirror get returnType {
     if (_cachedReturnType != null) return _cachedReturnType;
-    if (_isVoid) return _cachedReturnType = JsMirrorSystem._voidType;
-    if (!_hasReturnType) return _cachedReturnType = JsMirrorSystem._dynamicType;
+    if (_typeData.isVoid) return _cachedReturnType = JsMirrorSystem._voidType;
+    if (!_typeData.hasReturnType)
+      return _cachedReturnType = JsMirrorSystem._dynamicType;
     return _cachedReturnType =
-        typeMirrorFromRuntimeTypeRepresentation(_returnType);
+        typeMirrorFromRuntimeTypeRepresentation(_typeData.returnType);
   }
 
   List<ParameterMirror> get parameters {
     if (_cachedParameters != null) return _cachedParameters;
     List result = [];
     int parameterCount = 0;
-    if (_hasArguments) {
-      for (var type in _arguments) {
+    if (_typeData.hasArguments) {
+      for (var type in _typeData.arguments) {
         result.add(
             new JsParameterMirror('argument${parameterCount++}', this, type));
       }
     }
-    if (_hasOptionalArguments) {
-      for (var type in _optionalArguments) {
+    if (_typeData.hasOptionalArguments) {
+      for (var type in _typeData.optionalArguments) {
         result.add(
             new JsParameterMirror('argument${parameterCount++}', this, type));
       }
     }
-    if (_hasNamedArguments) {
-      for (var name in extractKeys(_namedArguments)) {
-        var type = JS('', '#[#]', _namedArguments, name);
+    if (_typeData.hasNamedArguments) {
+      for (var name in extractKeys(_typeData.namedArguments)) {
+        var type = JS('', '#[#]', _typeData.namedArguments, name);
         result.add(new JsParameterMirror(name, this, type));
       }
     }
     return _cachedParameters = new UnmodifiableListView<ParameterMirror>(
         result);
   }
 
   String toString() {
     if (_cachedToString != null) return _cachedToString;
-    var s = "FunctionTypeMirror on '(";
-    var sep = '';
-    if (_hasArguments) {
-      for (var argument in _arguments) {
-        s += runtimeTypeToString(argument);
-        s += sep;
-        sep = ', ';
-      }
-    }
-    if (_hasOptionalArguments) {
-      s += '$sep[';
-      sep = '';
-      for (var argument in _optionalArguments) {
-        s += runtimeTypeToString(argument);
-        s += sep;
-        sep = ', ';
-      }
-      s += ']';
-    }
-    if (_hasNamedArguments) {
-      s += '$sep{';
-      sep = '';
-      for (var name in extractKeys(_namedArguments)) {
-        s += '$name: ';
-        s += runtimeTypeToString(JS('', '#[#]', _namedArguments, name));
-        s += sep;
-        sep = ', ';
-      }
-      s += '}';
-    }
-    s += ') -> ';
-    if (_isVoid) {
-      s += 'void';
-    } else if (_hasReturnType) {
-      s += runtimeTypeToString(_returnType);
-    } else {
-      s += 'dynamic';
-    }
-    return _cachedToString = "$s'";
+    return _cachedToString = "FunctionTypeMirror on '$_typeData'";
   }
 }
 
 TypeMirror typeMirrorFromRuntimeTypeRepresentation(type) {
   if (type == null) return JsMirrorSystem._dynamicType;
   String representation = runtimeTypeToString(type);
   if (representation == null) return reflectClass(Function);
   return reflectClass(createRuntimeType(representation));
 }
 
@@ skipping 112 matching lines @@
   void operator []=(K key, V value) => _throw();
 
   V putIfAbsent(K key, V ifAbsent()) { _throw(); }
 
   void addAll(Map<K, V> other) => _throw();
 
   V remove(K key) { _throw(); }
 
   void clear() => _throw();
 }