Use the runtime for generic subsitution of variable types, return types, parameter types.

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";
 
 final emptyList = new UnmodifiableListView([]);
 final emptyMap = new _UnmodifiableMapView({});
@@ skipping 401 matching lines @@
         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;
   }
 
   Symbol _simpleName;
@@ skipping 342 matching lines @@
   MethodMirror get callMethod {
     if (_callMethod == null) {
       _callMethod = this._FunctionTypeMirror_call_method(_reflectee);
     }
     return _callMethod;
   }
 
   TypeMirror _returnType = null;
   TypeMirror get returnType {
     if (_returnType == null) {
-      _returnType = reflectType(_FunctionTypeMirror_return_type(_reflectee));
-      _returnType = _returnType._instantiateInContextOf(reflectType(_instantiator));
+      _returnType = reflectType(
+          _FunctionTypeMirror_return_type(_reflectee, _instantiator));
     }
     return _returnType;
   }
 
   List<ParameterMirror> _parameters = null;
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _FunctionTypeMirror_parameters(_reflectee);
-      _parameters.forEach((p) {
-        p._type = p.type._instantiateInContextOf(reflectType(_instantiator));
-      });
       _parameters = new UnmodifiableListView(_parameters);
     }
     return _parameters;
   }
 
   bool get isOriginalDeclaration => true;
   get originalDeclaration => this;
   get typeVariables => emptyList;
   get typeArguments => emptyList;
   get metadata => emptyList;
   Map<Symbol, Mirror> get members => emptyMap;
   Map<Symbol, MethodMirror> get constructors => emptyMap;
 
   String toString() => "FunctionTypeMirror on '${_n(simpleName)}'";
 
   MethodMirror _FunctionTypeMirror_call_method(reflectee)
       native "FunctionTypeMirror_call_method";
 
-  static Type _FunctionTypeMirror_return_type(reflectee)
+  static Type _FunctionTypeMirror_return_type(reflectee, instantiator)
       native "FunctionTypeMirror_return_type";
 
   List<ParameterMirror> _FunctionTypeMirror_parameters(reflectee)
       native "FunctionTypeMirror_parameters";
 }
 
 abstract class _LocalDeclarationMirrorImpl extends _LocalMirrorImpl
     implements DeclarationMirror {
   _LocalDeclarationMirrorImpl(this._reflectee, this._simpleName);
 
@@ skipping 73 matching lines @@
         && 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) {
-    var instantiator = declaration;
-    while (instantiator is MethodMirror) instantiator = instantiator.owner;
-    if (instantiator is LibraryMirror) return this;
-    if (!(instantiator is ClassMirror || instantiator is TypedefMirror))
-      throw "UNREACHABLE";
-    if (instantiator.isOriginalDeclaration) return this;
-
-    return reflectType(
-        _TypeVariableMirror_instantiate_from(_reflectee,
-                                             instantiator._reflectedType));
-  }
 }
 
 
 class _LocalTypedefMirrorImpl extends _LocalDeclarationMirrorImpl
     implements TypedefMirror {
   _LocalTypedefMirrorImpl(reflectee,
                           this._reflectedType,
                           String simpleName,
                           this._isGeneric,
                           this._isGenericDeclaration,
@@ skipping 60 matching lines @@
       if(_isGenericDeclaration) {
         _typeArguments = emptyList;
       } else {
         _typeArguments = new UnmodifiableListView(
             _LocalClassMirrorImpl._computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
-  TypeMirror _instantiateInContextOf(declaration) {
-    var instantiator = declaration;
-    while (instantiator is MethodMirror) instantiator = instantiator.owner;
-    if (instantiator is LibraryMirror) return this;
-    if (!(instantiator is ClassMirror || instantiator is TypedefMirror))
-      throw "UNREACHABLE";
-
-    return reflectType(
-        _nativeInstatniateFrom(_reflectedType, instantiator._reflectedType));
-  }
-
   String toString() => "TypedefMirror on '${_n(simpleName)}'";
 
   static _nativeReferent(reflectedType)
       native "TypedefMirror_referent";
 
-  static _nativeInstatniateFrom(reflectedType, instantiator)
-      native "TypedefMirror_instantiate_from";
-
   static _nativeDeclaration(reflectedType)
       native "TypedefMirror_declaration";
 }
 
 class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
     implements LibraryMirror {
   _LocalLibraryMirrorImpl(reflectee,
                           String simpleName,
                           String url)
       : this.simpleName = _s(simpleName),
         this.uri = Uri.parse(url),
         super(reflectee);
 
   final Symbol simpleName;
 
   // The simple name and the qualified name are the same for a library.
   Symbol get qualifiedName => simpleName;
 
   // Always null for libraries.
   final DeclarationMirror owner = null;
 
   // Always false for libraries.
   final bool isPrivate = false;
 
   // Always false for libraries.
   final bool isTopLevel = false;
 
+  Type get _instantiator => null;
+
   SourceLocation get location {
     throw new UnimplementedError('LibraryMirror.location is not implemented');
   }
 
   final Uri uri;
 
   Map<Symbol, DeclarationMirror> _declarations;
   Map<Symbol, DeclarationMirror> get declarations {
     if (_declarations != null) return _declarations;
     return _declarations =
@@ skipping 138 matching lines @@
 
   bool get isPrivate => _n(simpleName).startsWith('_') ||
                         _n(constructorName).startsWith('_');
 
   bool get isTopLevel =>  owner is LibraryMirror;
 
   SourceLocation get location {
     throw new UnimplementedError('MethodMirror.location is not implemented');
   }
 
+  Type get _instantiator {
+    var o = owner;
+    while (o is MethodMirror) o = o.owner;
+    return o._instantiator;
+  }
+
   TypeMirror _returnType = null;
   TypeMirror get returnType {
     if (_returnType == null) {
       if (isConstructor) {
         _returnType = owner;
       } else {
-        _returnType = reflectType(_MethodMirror_return_type(_reflectee));
+        _returnType = reflectType(
+            _MethodMirror_return_type(_reflectee, _instantiator));
       }
-      _returnType = _returnType._instantiateInContextOf(owner);
     }
     return _returnType;
   }
 
   List<ParameterMirror> _parameters = null;
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _MethodMirror_parameters(_reflectee);
       _parameters = new UnmodifiableListView(_parameters);
     }
@@ skipping 39 matching lines @@
     } else {
       _simpleName = _s(ownerName + "." + cn);
     }
   }
 
   String toString() => "MethodMirror on '${MirrorSystem.getName(simpleName)}'";
 
   static dynamic _MethodMirror_owner(reflectee)
       native "MethodMirror_owner";
 
-  static dynamic _MethodMirror_return_type(reflectee)
+  static dynamic _MethodMirror_return_type(reflectee, instantiator)
       native "MethodMirror_return_type";
 
   List<ParameterMirror> _MethodMirror_parameters(reflectee)
       native "MethodMirror_parameters";
 
   static String _MethodMirror_source(reflectee)
       native "MethodMirror_source";
 }
 
 class _LocalVariableMirrorImpl extends _LocalDeclarationMirrorImpl
@@ skipping 11 matching lines @@
   final bool isFinal;
 
   bool get isPrivate => _n(simpleName).startsWith('_');
 
   bool get isTopLevel => owner is LibraryMirror;
 
   SourceLocation get location {
     throw new UnimplementedError('VariableMirror.location is not implemented');
   }
 
+  Type get _instantiator {
+    return owner._instantiator;
+  }
+
   TypeMirror _type;
   TypeMirror get type {
     if (_type == null) {
-       _type = reflectType(_VariableMirror_type(_reflectee));
-       _type = _type._instantiateInContextOf(owner);
+       _type = reflectType(_VariableMirror_type(_reflectee, _instantiator));
     }
     return _type;
   }
 
   String toString() => "VariableMirror on '${MirrorSystem.getName(simpleName)}'";
 
-  static _VariableMirror_type(reflectee)
+  static _VariableMirror_type(reflectee, instantiator)
       native "VariableMirror_type";
 }
 
 class _LocalParameterMirrorImpl extends _LocalVariableMirrorImpl
     implements ParameterMirror {
   _LocalParameterMirrorImpl(reflectee,
                             String simpleName,
                             DeclarationMirror owner,
                             this._position,
                             this.isOptional,
@@ skipping 21 matching lines @@
     }
     if (_defaultValue == null) {
       _defaultValue = reflect(_defaultValueReflectee);
     }
     return _defaultValue;
   }
 
   bool get hasDefaultValue => _defaultValueReflectee != null;
 
   List<InstanceMirror> get metadata {
-    if ( _unmirroredMetadata == null) return emptyList;
+    if (_unmirroredMetadata == null) return emptyList;
     return new UnmodifiableListView(_unmirroredMetadata.map(reflect));
   }
 
+  Type get _instantiator {
+    var o = owner;
+    while (o is MethodMirror) o = o.owner;
+    return o._instantiator;
+  }
+
   TypeMirror _type = null;
   TypeMirror get type {
     if (_type == null) {
-      _type = reflectType(_ParameterMirror_type(_reflectee, _position));
-      _type = _type._instantiateInContextOf(owner);
+      _type = reflectType(
+          _ParameterMirror_type(_reflectee, _position, _instantiator));
     }
     return _type;
   }
 
   String toString() => "ParameterMirror on '${_n(simpleName)}'";
 
-  static Type _ParameterMirror_type(_reflectee, _position)
+  static Type _ParameterMirror_type(_reflectee, _position, instantiator)
       native "ParameterMirror_type";
 }
 
 class _SpecialTypeMirrorImpl extends _LocalMirrorImpl
     implements TypeMirror, DeclarationMirror {
   _SpecialTypeMirrorImpl(String name) : simpleName = _s(name);
 
   final bool isPrivate = false;
   final DeclarationMirror owner = null;
   final Symbol simpleName;
@@ skipping 17 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 39 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }