Fill in type arguments when creating an object from the mirrors or embedding API.

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 423 matching lines @@
   static _computeFunction(reflectee)
       native 'ClosureMirror_function';
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(reflectee,
                         this._reflectedType,
                         String simpleName,
                         this._isGeneric,
-                        this._isMixinTypedef)
+                        this._isMixinTypedef,
+                        this._isGenericDeclaration)
       : this._simpleName = _s(simpleName),
         super(reflectee);
 
   final Type _reflectedType;
   final bool _isGeneric;
   final bool _isMixinTypedef;
+  final bool _isGenericDeclaration;
 
-  bool get hasReflectedType => _reflectedType != null;
+  bool get hasReflectedType => !_isGenericDeclaration;
   Type get reflectedType {
     if (!hasReflectedType) {
       throw new UnsupportedError(
           "Declarations of generics have no reflected type");
     }
     return _reflectedType;
   }
 
   Symbol _simpleName;
   Symbol get simpleName {
@@ skipping 165 matching lines @@
             params[i + 1], params[i], this);
         _typeVariables[mirror.simpleName] = mirror;
       }
     }
     return _typeVariables;
   }
 
   Map<Symbol, TypeMirror> _typeArguments = null;
   Map<Symbol, TypeMirror> get typeArguments {
     if(_typeArguments == null) {
-      if(_reflectedType == null) {
+      if(_isGenericDeclaration) {
         _typeArguments = new LinkedHashMap<Symbol, TypeMirror>();
       } else {
         _typeArguments =
             new LinkedHashMap<Symbol, TypeMirror>.fromIterables(typeVariables.keys,
                                                                 _computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
   bool get isOriginalDeclaration {
-    return !_isGeneric || _reflectedType == null;
+    return !_isGeneric || _isGenericDeclaration;
   }
 
   ClassMirror get originalDeclaration {
     if (isOriginalDeclaration) {
       return this;
     } else {
       return reflectClass(_reflectedType);
     }
   }
 
@@ skipping 15 matching lines @@
     int argumentIndex = numPositionalArguments;
     int nameIndex = 0;
     if (numNamedArguments > 0) {
       namedArguments.forEach((name, value) {
         arguments[argumentIndex++] = value;
         names[nameIndex++] = _n(name);
       });
     }
 
     return reflect(_invokeConstructor(_reflectee,
+                                      _reflectedType,
                                       _n(constructorName),
                                       arguments,
                                       names));
   }
 
   Future<InstanceMirror> newInstanceAsync(Symbol constructorName,
                                           List positionalArguments,
                                           [Map<Symbol, dynamic> namedArguments]) {
     return new Future(() {
       return this.newInstance(constructorName,
                               _unwarpAsyncPositionals(positionalArguments),
                               _unwarpAsyncNamed(namedArguments));
     });
   }
 
   List<InstanceMirror> get metadata {
     // Get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list.
     return _metadata(_reflectee).map(reflect).toList(growable:false);
   }
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
            this._reflectee == other._reflectee &&
-           this._reflectedType == other._reflectedType;
+           this._reflectedType == other._reflectedType &&
+           this._isGenericDeclaration == other._isGenericDeclaration;
   }
 
   int get hashCode => simpleName.hashCode;
 
   static _library(reflectee)
       native "ClassMirror_library";
 
   static _supertype(reflectee)
       native "ClassMirror_supertype";
 
@@ skipping 11 matching lines @@
 
   _invoke(reflectee, memberName, arguments, argumentNames)
       native 'ClassMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'ClassMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'ClassMirror_invokeSetter';
 
-  static _invokeConstructor(reflectee, constructorName, arguments, argumentNames)
+  static _invokeConstructor(reflectee, type, constructorName, arguments, argumentNames)
       native 'ClassMirror_invokeConstructor';
 
   static _ClassMirror_type_variables(reflectee)
       native "ClassMirror_type_variables";
 
   static _computeTypeArguments(reflectee)
       native "ClassMirror_type_arguments";
 }
 
 class _LocalFunctionTypeMirrorImpl extends _LocalClassMirrorImpl
     implements FunctionTypeMirror {
   _LocalFunctionTypeMirrorImpl(reflectee, reflectedType)
-      : super(reflectee, reflectedType, null, false, false);
+      : super(reflectee, reflectedType, null, false, false, 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;
   }
 
@@ skipping 606 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }