Ensure FunctionTypeMirrors have a proper reflectee and implement ClassMirror.superinterfaces with i…

runtime/lib/mirrors_impl.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.
 
 // VM-specific implementation of the dart:mirrors library.
 
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
   return (value == null || value is num || value is String || value is bool);
 }
@@ skipping 107 matching lines @@
 
   TypeMirror get voidType {
     if (_voidType == null) {
       _voidType = new _SpecialTypeMirrorImpl('void');
     }
     return _voidType;
   }
 
   final Map<String, FunctionTypeMirror> _functionTypes;
   FunctionTypeMirror _lookupFunctionTypeMirror(
+      reflectee,
       TypeMirror returnType,
       List<ParameterMirror> parameters) {
     var sigString = _makeSignatureString(returnType, parameters);
     var mirror = _functionTypes[sigString];
     if (mirror == null) {
-      mirror = new _LocalFunctionTypeMirrorImpl(null,
+      mirror = new _LocalFunctionTypeMirrorImpl(reflectee,
                                                 sigString,
                                                 returnType,
                                                 parameters);
       _functionTypes[sigString] = mirror;
     }
     return mirror;
   }
 
   String toString() => "MirrorSystem for isolate '${isolate.debugName}'";
 }
@@ skipping 245 matching lines @@
   }
 
   final String libraryUrl;
   final Symbol typeName;
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(reflectee,
                         String simpleName,
-                        this.isClass,
-                        this._owner,
-                        this._superclass,
-                        this._superinterfaces,
-                        this._defaultFactory,
                         Map<String, Mirror> typeVariables)
       : this._simpleName = _s(simpleName),
         this.typeVariables = _convertStringToSymbolMap(typeVariables),
         super(reflectee);
 
   Symbol _simpleName;
   Symbol get simpleName {
     // dynamic, void and the function types have their names set eagerly in the
     // constructor.
     if(_simpleName == null) {
       _simpleName = _s(_name(_reflectee));
     }
     return _simpleName;
   }
 
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
   }
 
   var _owner;
   DeclarationMirror get owner {
     if (_owner == null) {
       _owner = _library(_reflectee);
     }
-    if (_owner is! Mirror) {
-      _owner = _owner.resolve(mirrors);
-    }
     return _owner;
   }
 
   bool get isPrivate => _n(simpleName).startsWith('_');
 
   final bool isTopLevel = true;
 
   SourceLocation get location {
     throw new UnimplementedError(
         'ClassMirror.location is not implemented');
   }
 
-  final bool isClass;
+  // TODO(rmacnak): Remove these left-overs from the days of separate interfaces
+  // once we send out a breaking change.
+  bool get isClass => true;
+  ClassMirror get defaultFactory => null;
 
   var _superclass;
   ClassMirror get superclass {
     if (_superclass == null) {
       Type supertype = _supertype(_reflectee);
       if (supertype == null) {
         // Object has no superclass.
         return null;
       }
       _superclass = reflectClass(supertype);
     }
     if (_superclass is! Mirror) {
       _superclass = _superclass.resolve(mirrors);
     }
     return _superclass;
   }
 
   var _superinterfaces;
   List<ClassMirror> get superinterfaces {
-    if (_superinterfaces.length > 0 &&
-        _superinterfaces[0] is! Mirror) {
-      List<ClassMirror> resolved = new List<ClassMirror>();
-      for (int i = 0; i < _superinterfaces.length; i++) {
-        resolved.add(_superinterfaces[i].resolve(mirrors));
-      }
-      _superinterfaces = resolved;
+    if (_superinterfaces == null) {
+      _superinterfaces = _interfaces(_reflectee)
+          .map((i) => reflectClass(i)).toList(growable:false);
     }
     return _superinterfaces;
   }
 
-  var _defaultFactory;
-  ClassMirror get defaultFactory {
-    if (_defaultFactory != null && _defaultFactory is! Mirror) {
-      _defaultFactory = _defaultFactory.resolve(mirrors);
-    }
-    return _defaultFactory;
-  }
-
   Map<Symbol, Mirror> _members;
 
   Map<Symbol, Mirror> get members {
     if (_members == null) {
       _members = _makeMemberMap(_computeMembers(_reflectee));
     }
     return _members;
   }
 
   Map<Symbol, MethodMirror> _methods = null;
@@ skipping 57 matching lines @@
     throw new UnimplementedError(
         'ClassMirror.isOriginalDeclaration is not implemented');
   }
 
   ClassMirror get genericDeclaration {
     throw new UnimplementedError(
         'ClassMirror.originalDeclaration is not implemented');
   }
 
   String toString() {
-    String prettyName = isClass ? 'ClassMirror' : 'TypeMirror';
-    return "$prettyName on '${_n(simpleName)}'";
+    return "ClassMirror on '${_n(simpleName)}'";
   }
 
   InstanceMirror newInstance(Symbol constructorName,
                              List positionalArguments,
                              [Map<Symbol, dynamic> namedArguments]) {
     if (namedArguments != null) {
       throw new UnimplementedError(
           'named argument support is not implemented');
     }
     return reflect(_invokeConstructor(_reflectee,
@@ skipping 27 matching lines @@
 
   static _name(reflectee)
       native "ClassMirror_name";
 
   static _library(reflectee)
       native "ClassMirror_library";
 
   static _supertype(reflectee)
       native "ClassMirror_supertype";
 
+  static _interfaces(reflectee)
+      native "ClassMirror_interfaces";
+
   _computeMembers(reflectee)
       native "ClassMirror_members";
   
   _computeConstructors(reflectee)
       native "ClassMirror_constructors";
 
   _invoke(reflectee, memberName, positionalArguments)
       native 'ClassMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'ClassMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'ClassMirror_invokeSetter';
 
   static _invokeConstructor(reflectee, constructorName, positionalArguments)
       native 'ClassMirror_invokeConstructor';
 }
 
 class _LazyFunctionTypeMirror {
-  _LazyFunctionTypeMirror(this.returnType, this.parameters) {}
+  _LazyFunctionTypeMirror(this.reflectee, this.returnType, this.parameters) {}
 
   ClassMirror resolve(MirrorSystem mirrors) {
-    return mirrors._lookupFunctionTypeMirror(returnType.resolve(mirrors),
+    return mirrors._lookupFunctionTypeMirror(reflectee,
+                                             returnType.resolve(mirrors),
                                              parameters);
   }
 
+  final reflectee;
   final returnType;
   final List<ParameterMirror> parameters;
 }
 
 class _LocalFunctionTypeMirrorImpl extends _LocalClassMirrorImpl
     implements FunctionTypeMirror {
   _LocalFunctionTypeMirrorImpl(reflectee,
                                simpleName,
                                this._returnType,
                                this.parameters)
       : super(reflectee,
               simpleName,
-              true,
-              null,
-              new _LazyTypeMirror('dart:core', 'Object'),
-              [ new _LazyTypeMirror('dart:core', 'Function') ],
-              null,
               const {});
 
   Map<Symbol, Mirror> get members => new Map<Symbol,Mirror>();
   Map<Symbol, MethodMirror> get constructors => new Map<Symbol,MethodMirror>();
 
   var _returnType;
   TypeMirror get returnType {
     if (_returnType is! Mirror) {
       _returnType = _returnType.resolve(mirrors);
     }
@@ skipping 567 matching lines @@
   static Expando<ClassMirror> _classMirrorCache = new Expando("ClassMirror");
   static ClassMirror reflectClass(Type key) {
     var classMirror = _classMirrorCache[key];
     if (classMirror == null) {
       classMirror = makeLocalClassMirror(key);
       _classMirrorCache[key] = classMirror;
     }
     return classMirror;
   }
 }