Instantations of mixins and interfaces. Equality of type parameters.

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.
 
 import "dart:collection";
 
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
@@ skipping 402 matching lines @@
   static _computeFunction(reflectee)
       native 'ClosureMirror_function';
 
   static _computeFindInContext(reflectee, name)
       native 'ClosureMirror_find_in_context';
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(reflectee,
-                        this._reflectedType,
+                        reflectedType,
                         String simpleName,
                         this._isGeneric,
                         this._isMixinTypedef,
                         this._isGenericDeclaration)
       : this._simpleName = _s(simpleName),
+        this._reflectedType = reflectedType,
+        this._instantiator = reflectedType,
         super(reflectee);
 
   final Type _reflectedType;
   final bool _isGeneric;
   final bool _isMixinTypedef;
   final bool _isGenericDeclaration;
+  Type _instantiator;
 
   TypeMirror _instantiateInContextOf(declaration) => this;
 
   bool get hasReflectedType => !_isGenericDeclaration;
   Type get reflectedType {
     if (!hasReflectedType) {
       throw new UnsupportedError(
           "Declarations of generics have no reflected type");
     }
     return _reflectedType;
@@ skipping 41 matching lines @@
   ClassMirror get _trueSuperclass {
     if (_trueSuperclassField == null) {
       Type supertype = isOriginalDeclaration
           ? _supertype(_reflectedType)
           : _supertypeInstantiated(_reflectedType);
       if (supertype == null) {
         // Object has no superclass.
         return null;
       }
       _trueSuperclassField = _Mirrors._reflectType(supertype);
+      _trueSuperclassField._instantiator = _instantiator;
     }
     return _trueSuperclassField;
   }
   ClassMirror get superclass {
     return _isMixinTypedef ? _trueSuperclass._trueSuperclass : _trueSuperclass;
   }
 
   var _superinterfaces;
   List<ClassMirror> get superinterfaces {
     if (_superinterfaces == null) {
-      _superinterfaces = _interfaces(_reflectee)
+      _superinterfaces = isOriginalDeclaration
+          ? _nativeInterfaces(_reflectedType)
+          : _nativeInterfacesInstantiated(_reflectedType);
+      _superinterfaces = _superinterfaces
           .map((i) => _Mirrors._reflectType(i)).toList(growable:false);
     }
     return _superinterfaces;
   }
 
   get _mixinApplicationName {
     var mixins = new List<ClassMirror>();
     var klass = this;
-    while (_computeMixin(klass._reflectee) != null) {
+    while (_nativeMixin(klass._reflectedType) != null) {
       mixins.add(klass.mixin);
       klass = klass.superclass;
     }
     return _s(
       _n(klass.qualifiedName)
       + ' with '
       + mixins.reversed.map((m)=>_n(m.qualifiedName)).join(', '));
   }
 
   var _mixin;
   ClassMirror get mixin {
     if (_mixin == null) {
       if (_isMixinTypedef) {
-        _mixin = _trueSuperclass.mixin;
+        Type mixinType = isOriginalDeclaration
+            ? _nativeMixin(_trueSuperclass._reflectedType)
+            : _nativeMixinInstantiated(_trueSuperclass._reflectedType, _instantiator);
+        _mixin = _Mirrors._reflectType(mixinType);
       } else {
-        var mixinType = _computeMixin(_reflectee);
+        Type mixinType = isOriginalDeclaration
+            ? _nativeMixin(_reflectedType)
+            : _nativeMixinInstantiated(_reflectedType, _instantiator);
         if (mixinType == null) {
           // The reflectee is not a mixin application.
           _mixin = this;
         } else {
           _mixin = _Mirrors._reflectType(mixinType);
         }
       }
     }
     return _mixin;
   }
@@ skipping 160 matching lines @@
 
   static _library(reflectee)
       native "ClassMirror_library";
 
   static _supertype(reflectedType)
       native "ClassMirror_supertype";
 
   static _supertypeInstantiated(reflectedType)
       native "ClassMirror_supertype_instantiated";
 
-  static _interfaces(reflectee)
+  static _nativeInterfaces(reflectedType)
       native "ClassMirror_interfaces";
 
-  static _computeMixin(reflectee)
+  static _nativeInterfacesInstantiated(reflectedType)
+      native "ClassMirror_interfaces_instantiated";
+
+  static _nativeMixin(reflectedType)
       native "ClassMirror_mixin";
 
+  static _nativeMixinInstantiated(reflectedType, instantiator)
+      native "ClassMirror_mixin_instantiated";
+
   _computeMembers(reflectee)
       native "ClassMirror_members";
 
   _computeConstructors(reflectee)
       native "ClassMirror_constructors";
 
   _invoke(reflectee, memberName, arguments, argumentNames)
       native 'ClassMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
@@ skipping 10 matching lines @@
 
   static _computeTypeArguments(reflectee)
       native "ClassMirror_type_arguments";
 }
 
 class _LocalFunctionTypeMirrorImpl extends _LocalClassMirrorImpl
     implements FunctionTypeMirror {
   _LocalFunctionTypeMirrorImpl(reflectee, reflectedType)
       : super(reflectee, reflectedType, null, false, false, false);
 
+  bool get _isAnonymousMixinApplication => false;
+
   // FunctionTypeMirrors have a simpleName generated from their signature.
   Symbol _simpleName = null;
   Symbol get simpleName {
     if (_simpleName == null) {
       _simpleName = _s(_makeSignatureString(returnType, parameters));
     }
     return _simpleName;
   }
 
   MethodMirror _callMethod;
@@ skipping 104 matching lines @@
   Type get reflectedType => throw new UnsupportedError() ;
 
   List<TypeVariableMirror> get typeVariables => new UnmodifiableListView<TypeVariableMirror>();
   List<TypeMirror> get typeArguments => new UnmodifiableListView<TypeMirror>();
 
   bool get isOriginalDeclaration => true;
   TypeMirror get originalDeclaration => this;
 
   String toString() => "TypeVariableMirror on '${_n(simpleName)}'";
 
+  operator ==(other) {
+    return other is TypeVariableMirror 
+        && simpleName == other.simpleName
+        && owner == other.owner;
+  }
+  int get hashCode => simpleName.hashCode;
+
   static DeclarationMirror _TypeVariableMirror_owner(reflectee)
       native "TypeVariableMirror_owner";
 
   static Type _TypeVariableMirror_upper_bound(reflectee)
       native "TypeVariableMirror_upper_bound";
 
   static Type _TypeVariableMirror_instantiate_from(reflectee, instantiator)
       native "TypeVariableMirror_instantiate_from";
 
   TypeMirror _instantiateInContextOf(declaration) {
@@ skipping 484 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }