Support reflectClass on parameterized classes

pkg/dev_compiler/tool/input_sdk/private/js_mirrors.dart

 // Copyright (c) 2015, 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.
 
 library dart._js_mirrors;
 
 import 'dart:mirrors';
 import 'dart:_foreign_helper' show JS;
 import 'dart:_internal' as _internal;
 
@@ skipping 293 matching lines @@
   InstanceMirror apply(List<dynamic> args, [Map<Symbol, dynamic> namedArgs]) {
     if (namedArgs != null) {
       args = new List.from(args);
       args.add(_toJsMap(namedArgs));
     }
     var result = _dcall(reflectee, args);
     return reflect(result);
   }
 }
 
+// For generic classes, mirrors uses the same representation, [ClassMirror],
+// for the instantiated and uninstantiated type.  Somewhat awkwardly, most APIs
+// (e.g., [newInstance]) treat the uninstantiated type as if instantiated
+// with all dynamic.  The representation below is correspondingly a bit wonky.
+// For an uninstantiated generic class, [_cls] is the instantiated type (with
+// dynamic) and [_raw] is null.  For an instantiated generic class, [_cls] is
+// the instantiated type (with the corresponding type parameters), and [_raw]
+// is the generic factory.
 class JsClassMirror extends JsMirror implements ClassMirror {
   final Type _cls;
   final Symbol simpleName;
-  // Generic class factory
+  // Generic class factory for instantiated types.
   final dynamic _raw;
 
+  ClassMirror _originalDeclaration;
+
   // TODO(vsm): Do this properly
   ClassMirror _mixin = null;
   List<TypeMirror> _typeArguments;
 
   List<InstanceMirror> _metadata;
   Map<Symbol, DeclarationMirror> _declarations;
 
   List<InstanceMirror> get metadata {
     if (_metadata == null) {
       // Load metadata.
@@ skipping 77 matching lines @@
         var name = getName(symbol);
         _declarations[symbol] =
             new JsMethodMirror._staticMethod(this, symbol, ft);
       });
       _declarations =
           new Map<Symbol, DeclarationMirror>.unmodifiable(_declarations);
     }
     return _declarations;
   }
 
-  JsClassMirror._(Type cls)
+  JsClassMirror._(Type cls, {bool instantiated: true})
       : _cls = cls,
-        _raw = _getGenericClass(_unwrap(cls)),
+        _raw = instantiated ? _getGenericClass(_unwrap(cls)) : null,
         simpleName = new Symbol(JS('String', '#.name', _unwrap(cls))) {
-    var typeArgs = _getGenericArgs(_unwrap(cls));
+    var typeArgs = _getGenericArgs(_unwrap(_cls));
     if (typeArgs == null) {
       _typeArguments = const [];
     } else {
       _typeArguments =
           new List.unmodifiable(typeArgs.map((t) => reflectType(_wrap(t))));
     }
   }
 
   InstanceMirror newInstance(Symbol constructorName, List args,
       [Map<Symbol, dynamic> namedArgs]) {
@@ skipping 46 matching lines @@
   bool get hasReflectedType => true;
   Type get reflectedType {
     return _cls;
   }
 
   bool get isOriginalDeclaration => _raw == null;
 
   List<TypeMirror> get typeArguments => _typeArguments;
 
   TypeMirror get originalDeclaration {
-    // TODO(vsm): Handle generic case.  How should we represent an original
-    // declaration for a generic class?
     if (_raw == null) {
       return this;
     }
-    throw new UnimplementedError(
-        "ClassMirror.originalDeclaration unimplemented");
+    if (_originalDeclaration != null) {
+      return _originalDeclaration;
+    }
+    _originalDeclaration =
+        new JsClassMirror._(_wrap(JS('', '#()', _raw)), instantiated: false);
+    return _originalDeclaration;
   }
 
   ClassMirror get superclass {
     if (_cls == Object) {
       return null;
     } else {
       return reflectType(_wrap(JS('Type', '#.__proto__', _unwrap(_cls))));
     }
   }
 
@@ skipping 142 matching lines @@
       var param =
           new JsParameterMirror._(new Symbol(''), _wrap(type), metadata);
       params[i + args.length] = param;
     }
 
     _params = new List.unmodifiable(params);
   }
 
   String toString() => "MethodMirror on '$_name'";
 }