Substitution for type variables in mirrors on instantiated generics.

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 415 matching lines @@
                         this._isMixinTypedef,
                         this._isGenericDeclaration)
       : this._simpleName = _s(simpleName),
         super(reflectee);
 
   final Type _reflectedType;
   final bool _isGeneric;
   final bool _isMixinTypedef;
   final bool _isGenericDeclaration;
 
+  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;
   }
 
   Symbol _simpleName;
@@ skipping 25 matching lines @@
 
   final bool isTopLevel = true;
 
   SourceLocation get location {
     throw new UnimplementedError('ClassMirror.location is not implemented');
   }
 
   // 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;

[regis, 2013/10/09 15:46:51]

Would it be a good time for cleanup? Default factories have been gone for quite
some time. Not in this cl, if this is more involved than just removing these
lines.

[rmacnak, 2013/10/11 01:04:22]

This is already in another CL.

 
   ClassMirror _trueSuperclassField;
   ClassMirror get _trueSuperclass {
     if (_trueSuperclassField == null) {
-      Type supertype = _supertype(_reflectee);
+      Type supertype = isOriginalDeclaration
+          ? _supertype(_reflectedType)

[rmacnak, 2013/10/09 01:15:00]

Unfortunately, this is not the same as reflecting on the instantiated supertype
and getting its original declaration.

[ahe, 2013/10/10 16:53:38]

Why?

[rmacnak, 2013/10/11 01:04:22]

Consider
class S<T>
class C<R> extends S<R>

The superclass of the declaration of C is S<R>, not the declaration of S.

[ahe, 2013/10/11 12:43:34]

I'm not sure I understand this. What is the difference between _supertype and
_supertypeInstantiated?

+          : _supertypeInstantiated(_reflectedType);
       if (supertype == null) {
         // Object has no superclass.
         return null;
       }
       _trueSuperclassField = _Mirrors._reflectType(supertype);
     }
     return _trueSuperclassField;
   }
   ClassMirror get superclass {
     return _isMixinTypedef ? _trueSuperclass._trueSuperclass : _trueSuperclass;
@@ skipping 92 matching lines @@
   Map<Symbol, MethodMirror> get constructors {
     if (_constructors == null) {
       var constructorsList = _computeConstructors(_reflectee);
       var stringName = _n(simpleName);
       constructorsList.forEach((c) => c._patchConstructorName(stringName));
       _constructors = _makeMemberMap(constructorsList);
     }
     return _constructors;
   }
 
+  bool get _isAnonymousMixinApplication {
+    if (_isMixinTypedef) return false;  // Named mixin application.
+    if (mixin == this) return false;  // Not a mixin application.
+    return true;
+  }
+
   List<TypeVariableMirror> _typeVariables = null;
   List<TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
+      _typeVariables = new List<TypeVariableMirror>();
+      if (_isAnonymousMixinApplication) return _typeVariables;
+
       List params = _ClassMirror_type_variables(_reflectee);
-      _typeVariables = new List<TypeVariableMirror>();
       var mirror;
       for (var i = 0; i < params.length; i += 2) {
         mirror = new _LocalTypeVariableMirrorImpl(
             params[i + 1], params[i], this);
         _typeVariables.add(mirror);
       }
     }
     return _typeVariables;
   }
 
   List<TypeMirror> _typeArguments = null;
   List<TypeMirror> get typeArguments {
     if(_typeArguments == null) {
-      if(_isGenericDeclaration) {
+      if(_isGenericDeclaration || _isAnonymousMixinApplication) {
         _typeArguments = new List<TypeMirror>();
       } else {
         _typeArguments =
             new List<TypeMirror>.from(_computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
   bool get isOriginalDeclaration => !_isGeneric || _isGenericDeclaration;
@@ skipping 56 matching lines @@
            this._reflectee == other._reflectee &&
            this._reflectedType == other._reflectedType &&
            this._isGenericDeclaration == other._isGenericDeclaration;
   }
 
   int get hashCode => simpleName.hashCode;
 
   static _library(reflectee)
       native "ClassMirror_library";
 
-  static _supertype(reflectee)
+  static _supertype(reflectedType)
       native "ClassMirror_supertype";
 
+  static _supertypeInstantiated(reflectedType)
+      native "ClassMirror_supertype_instantiated";
+
   static _interfaces(reflectee)
       native "ClassMirror_interfaces";
 
   static _computeMixin(reflectee)
       native "ClassMirror_mixin";
 
   _computeMembers(reflectee)
       native "ClassMirror_members";
 
   _computeConstructors(reflectee)
@@ skipping 139 matching lines @@
   bool get isOriginalDeclaration => true;
   ClassMirror get originalDeclaration => this;
 
   String toString() => "TypeVariableMirror on '${_n(simpleName)}'";
 
   static DeclarationMirror _TypeVariableMirror_owner(reflectee)
       native "TypeVariableMirror_owner";
 
   static Type _TypeVariableMirror_upper_bound(reflectee)
       native "TypeVariableMirror_upper_bound";
+
+  static Type _TypeVariableMirror_instantiate_from(reflectee, instantator)

[regis, 2013/10/09 15:46:51]

instantiator

[rmacnak, 2013/10/11 01:04:22]

Done.

+      native "TypeVariableMirror_instantiate_from";
+
+  TypeMirror _instantiateInContextOf(declaration) {
+    var instantator = declaration;
+    while (instantator is MethodMirror) instantator = instantator.owner;

[regis, 2013/10/09 15:46:51]

ditto

+    if (instantator is LibraryMirror) return this;
+    if (instantator is! ClassMirror) throw "UNREACHABLE";
+    if (instantator.isOriginalDeclaration) return this;
+
+    return _Mirrors._reflectType(
+        _TypeVariableMirror_instantiate_from(
+            _reflectee,
+            instantator._reflectedType));
+  }
 }
 
 
 class _LocalTypedefMirrorImpl extends _LocalDeclarationMirrorImpl
     implements TypedefMirror {
   _LocalTypedefMirrorImpl(reflectee,
                           String simpleName,
                           this._owner)
       : super(reflectee, _s(simpleName));
 
@@ skipping 23 matching lines @@
       return new _LocalFunctionTypeMirrorImpl(
           _TypedefMirror_referent(_reflectee), null);
     }
     return _referent;
   }
 
   String toString() => "TypedefMirror on '${_n(simpleName)}'";
 
   static _TypedefMirror_referent(_reflectee)
       native "TypedefMirror_referent";
+
+  // TODO(12282): This is wrong.
+  TypeMirror _instantiateInContextOf(declaration) => this;
 }
 
 class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
     implements LibraryMirror {
   _LocalLibraryMirrorImpl(reflectee,
                           String simpleName,
                           String url)
       : this.simpleName = _s(simpleName),
         this.uri = Uri.parse(url),
         super(reflectee);
@@ skipping 148 matching lines @@
 
   TypeMirror _returnType = null;
   TypeMirror get returnType {
     if (_returnType == null) {
       if (isConstructor) {
         _returnType = owner;
       } else {
         _returnType =
             _Mirrors._reflectType(_MethodMirror_return_type(_reflectee));
       }
+      _returnType = _returnType._instantiateInContextOf(owner);
     }
     return _returnType;
   }
 
   List<ParameterMirror> _parameters = null;
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _MethodMirror_parameters(_reflectee);
     }
     return _parameters;
@@ skipping 74 matching lines @@
   bool get isTopLevel => owner is LibraryMirror;
 
   SourceLocation get location {
     throw new UnimplementedError('VariableMirror.location is not implemented');
   }
 
   TypeMirror _type;
   TypeMirror get type {
     if (_type == null) {
        _type = _Mirrors._reflectType(_VariableMirror_type(_reflectee));
+       _type = _type._instantiateInContextOf(owner);
     }
     return _type;
   }
 
   String toString() => "VariableMirror on '${_n(simpleName)}'";
 
   static _VariableMirror_type(reflectee)
       native "VariableMirror_type";
 }
 
@@ skipping 37 matching lines @@
   List<InstanceMirror> get metadata {
     if ( _unmirroredMetadata == null) return const [];
     return _unmirroredMetadata.map(reflect).toList(growable:false);
   }
 
   TypeMirror _type = null;
   TypeMirror get type {
     if (_type == null) {
       _type =
           _Mirrors._reflectType(_ParameterMirror_type(_reflectee, _position));
+      _type = _type._instantiateInContextOf(owner);
     }
     return _type;
   }
 
   String toString() => "ParameterMirror on '${_n(simpleName)}'";
 
   static Type _ParameterMirror_type(_reflectee, _position)
       native "ParameterMirror_type";
 }
 
@@ skipping 19 matching lines @@
   bool operator ==(other) {
     if (other is! _SpecialTypeMirrorImpl) {
       return false;
     }
     return this.simpleName == other.simpleName;
   }
 
   int get hashCode => simpleName.hashCode;
 
   String toString() => "TypeMirror on '${_n(simpleName)}'";
+
+  TypeMirror _instantiateInContextOf(declaration) => this;
 }
 
 class _Mirrors {
   // Does a port refer to our local isolate?
   static bool isLocalPort(SendPort port) native 'Mirrors_isLocalPort';
 
   static MirrorSystem _currentMirrorSystem = null;
 
   // Creates a new local MirrorSystem.
   static MirrorSystem makeLocalMirrorSystem()
@@ skipping 54 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }