Deal with type arguments of generic local functions in VM mirrors.

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" show UnmodifiableListView, UnmodifiableMapView;
 
 final emptyList = new UnmodifiableListView([]);
 final emptyMap = new UnmodifiableMapView({});
@@ skipping 675 matching lines @@
     return _s(
       _n(klass.qualifiedName)
       + ' with '
       + mixins.reversed.map((m)=>_n(m.qualifiedName)).join(', '));
   }
 
   var _mixin;
   ClassMirror get mixin {
     if (_mixin == null) {
       if (_isMixinAlias) {
-        Type mixinType = _nativeMixinInstantiated(_trueSuperclass._reflectedType,
-                                                  _instantiator);
+        Type mixinType = _nativeMixinInstantiated(
+            _trueSuperclass._reflectedType, _instantiator);
         _mixin = reflectType(mixinType);
       } else {
-        Type mixinType = _nativeMixinInstantiated(_reflectedType, _instantiator);
+        Type mixinType = _nativeMixinInstantiated(_reflectedType,
+                                                  _instantiator);
         if (mixinType == null) {
           // The reflectee is not a mixin application.
           _mixin = this;
         } else {
           _mixin = reflectType(mixinType);
         }
       }
     }
     return _mixin;
   }
@@ skipping 60 matching lines @@
     decls.addAll(_constructors);
     typeVariables.forEach((tv) => decls[tv.simpleName] = tv);
     return _declarations =
         new UnmodifiableMapView<Symbol, DeclarationMirror>(decls);
   }
 
   Map<Symbol, Mirror> _cachedMembers;
   Map<Symbol, Mirror> get _members {
     if (_cachedMembers == null) {
       var whoseMembers = _isMixinAlias ? _trueSuperclass : this;
-      _cachedMembers = _makeMemberMap(mixin._computeMembers(whoseMembers.mixin._reflectee));
+      _cachedMembers = _makeMemberMap(mixin._computeMembers(
+          _instantiator, whoseMembers.mixin._reflectee));
     }
     return _cachedMembers;
   }
 
   Map<Symbol, MethodMirror> _cachedMethods;
   Map<Symbol, MethodMirror> get _methods {
     if (_cachedMethods == null) {
       _cachedMethods = _filterMap(
           _members,
           (key, value) => (value is MethodMirror && value.isRegularMethod));
     }
     return _cachedMethods;
   }
 
   Map<Symbol, MethodMirror> _cachedConstructors;
   Map<Symbol, MethodMirror> get _constructors {
     if (_cachedConstructors == null) {
-      var constructorsList = _computeConstructors(_reflectee);
+      var constructorsList = _computeConstructors(_instantiator, _reflectee);
       var stringName = _n(simpleName);
       constructorsList.forEach((c) => c._patchConstructorName(stringName));
       _cachedConstructors =
           new Map.fromIterable(constructorsList, key: (e) => e.simpleName);
     }
     return _cachedConstructors;
   }
 
   bool get _isAnonymousMixinApplication {
     if (_isMixinAlias) return false;  // Named mixin application.
@@ skipping 126 matching lines @@
 
   static _nativeInterfacesInstantiated(reflectedType)
       native "ClassMirror_interfaces_instantiated";
 
   static _nativeMixin(reflectedType)
       native "ClassMirror_mixin";
 
   static _nativeMixinInstantiated(reflectedType, instantiator)
       native "ClassMirror_mixin_instantiated";
 
-  _computeMembers(reflectee)
+  _computeMembers(reflectee, instantiator)
       native "ClassMirror_members";
 
-  _computeConstructors(reflectee)
+  _computeConstructors(reflectee, instantiator)
       native "ClassMirror_constructors";
 
   _invoke(reflectee, memberName, arguments, argumentNames)
       native 'ClassMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'ClassMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'ClassMirror_invokeSetter';
@@ skipping 390 matching lines @@
   final bool isShow;
 
   _LocalCombinatorMirror(identifierString, this.isShow)
       : this.identifiers = [_s(identifierString)];
 
   bool get isHide => !isShow;
 }
 
 class _LocalMethodMirror extends _LocalDeclarationMirror
     implements MethodMirror {
+  final Type _instantiator;
   final bool isStatic;
   final bool isAbstract;
   final bool isGetter;
   final bool isSetter;
   final bool isConstructor;
   final bool isConstConstructor;
   final bool isGenerativeConstructor;
   final bool isRedirectingConstructor;
   final bool isFactoryConstructor;
   final bool isOperator;
 
   static const _operators = const ["%", "&", "*", "+", "-", "/", "<", "<<",
       "<=", "==", ">", ">=", ">>", "[]", "[]=", "^", "|", "~", "unary-", "~/"];
 
   _LocalMethodMirror(reflectee,
                      String simpleName,
                      this._owner,
+                     this._instantiator,
                      this.isStatic,
                      this.isAbstract,
                      this.isGetter,
                      this.isSetter,
                      this.isConstructor,
                      this.isConstConstructor,
                      this.isGenerativeConstructor,
                      this.isRedirectingConstructor,
                      this.isFactoryConstructor)
       : this.isOperator = _operators.contains(simpleName),
         super(reflectee, _s(simpleName));
 
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     // For nested closures it is possible, that the mirror for the owner has not
     // been created yet.
     if (_owner == null) {
-      _owner = _MethodMirror_owner(_reflectee);
+      _owner = _MethodMirror_owner(_reflectee, _instantiator);
     }
     return _owner;
   }
 
   bool get isPrivate => _n(simpleName).startsWith('_') ||
                         _n(constructorName).startsWith('_');
 
   bool get isTopLevel => owner is LibraryMirror;
   bool get isSynthetic => false;
 
-  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, _instantiator));
       }
     }
@@ skipping 45 matching lines @@
     var cn = _n(constructorName);
     if(cn == ''){
       _simpleName = _s(ownerName);
     } else {
       _simpleName = _s(ownerName + "." + cn);
     }
   }
 
   String toString() => "MethodMirror on '${MirrorSystem.getName(simpleName)}'";
 
-  static dynamic _MethodMirror_owner(reflectee)
+  static dynamic _MethodMirror_owner(reflectee, instantiator)
       native "MethodMirror_owner";
 
   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";
@@ skipping 77 matching lines @@
   SourceLocation get location {
     throw new UnsupportedError("ParameterMirror.location unimplemented");
   }
 
   List<InstanceMirror> get metadata {
     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;
+    return owner._instantiator;
   }
 
   TypeMirror _type = null;
   TypeMirror get type {
     if (_type == null) {
       _type = reflectType(
           _ParameterMirror_type(_reflectee, _position, _instantiator));
     }
     return _type;
   }
@@ skipping 101 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }