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)
-      : _cls = cls,
-        _raw = _getGenericClass(_unwrap(cls)),
-        simpleName = new Symbol(JS('String', '#.name', _unwrap(cls))) {
-    var typeArgs = _getGenericArgs(_unwrap(cls));
+  void _initialize() {
+    var typeArgs = _getGenericArgs(_unwrap(_cls));
     if (typeArgs == null) {
       _typeArguments = const [];
     } else {
       _typeArguments =
           new List.unmodifiable(typeArgs.map((t) => reflectType(_wrap(t))));
     }
   }
 
+  JsClassMirror._(Type cls)
+      : _cls = cls,
+        _raw = _getGenericClass(_unwrap(cls)),
+        simpleName = new Symbol(JS('String', '#.name', _unwrap(cls))) {
+    _initialize();
+  }
+
+  JsClassMirror._uninstantiated(Type cls)
+      : _cls = cls,
+        _raw = null,

[Bob Nystrom, 2017/05/25 20:16:05]

There's some duplication between these. Maybe a single constructor like:

JsClassMirror._(Type cls, {bool instantiated = true})
    : _cls = cls,
      _raw = instantiated ? _getGenericClass(_unwrap(cls)) : null,
      simpleName = new Symbol(JS('String', '#.name', _unwrap(cls))) {
  _initialize();
}

[vsm, 2017/05/25 20:26:52]

That is cleaner.  :-)  

Done and re-inlined initialize as well.

+        simpleName = new Symbol(JS('String', '#.name', _unwrap(cls))) {
+    _initialize();
+  }
+
   InstanceMirror newInstance(Symbol constructorName, List args,
       [Map<Symbol, dynamic> namedArgs]) {
     // TODO(vsm): Support factory constructors and named arguments.
     var name = getName(constructorName);
     assert(namedArgs == null || namedArgs.isEmpty);
     var instance = (name == 'new' || name == '')
         ? JS('', 'new #(...#)', _unwrap(_cls), args)
         : JS('', 'new (#.#)(...#)', _unwrap(_cls), name, args);
     return reflect(instance);
   }
@@ skipping 43 matching lines @@
   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._uninstantiated(_wrap(JS('', '#()', _raw)));
+    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'";
 }