Implement more of dart:mirrors

lib/src/codegen/js_codegen.dart

Index: lib/src/codegen/js_codegen.dart
diff --git a/lib/src/codegen/js_codegen.dart b/lib/src/codegen/js_codegen.dart
index 608628ea1af0dbea81b5dc626514f7ff42d5ebd1..d6aa7741403150b4fb84fcc60608ccb43fc35461 100644
--- a/lib/src/codegen/js_codegen.dart
+++ b/lib/src/codegen/js_codegen.dart
@@ -464,6 +464,7 @@ class JSCodegenVisitor extends GeneralizingAstVisitor {
       _emitTypeName(type)
     ]));
 
+    if (isPublic(type.name)) _addExport(type.name);
     return _statement(result);
   }
 
@@ -717,7 +718,7 @@ class JSCodegenVisitor extends GeneralizingAstVisitor {
       for (ConstructorDeclaration node in ctors) {
         var memberName = _constructorName(node.element);
         var element = node.element;
-        var parts = _emitFunctionTypeParts(element.type);
+        var parts = _emitFunctionTypeParts(element.type, node.parameters);
         var property =
             new JS.Property(memberName, new JS.ArrayInitializer(parts));
         tCtors.add(property);
@@ -1385,9 +1386,25 @@ class JSCodegenVisitor extends GeneralizingAstVisitor {
   JS.TemporaryId _getTemp(Element key, String name) =>
       _temps.putIfAbsent(key, () => new JS.TemporaryId(name));
 
-  JS.ArrayInitializer _emitTypeNames(List<DartType> types) {
-    return new JS.ArrayInitializer(
-        new List<JS.Expression>.from(types.map(_emitTypeName)));
+  JS.ArrayInitializer _emitTypeNames(List<DartType> types,

[Jennifer Messerly, 2015/07/24 16:28:28]

thought for future:
should we only emit mirrors under certain conditions, like when a flag is
passed?
anyway I filed https://github.com/dart-lang/dev_compiler/issues/268 for that

[vsm, 2015/08/07 17:07:32]

Makes sense.  Added a comment.

+      [List<FormalParameter> parameters]) {
+    var result = <JS.Expression>[];
+    for (int i = 0; i < types.length; ++i) {
+      var parameter = parameters != null ? parameters[i] : null;

[Jennifer Messerly, 2015/07/24 16:28:28]

parameters[i] will never be null right? i'd be tempted to restructure this a
bit:

List metadata = [];
if (parameters != null) {
  metadata = parameters[i].metadata; // see my comment below, this is an
analyzer API tweak  
}
var typeName = _emitTypeName(types[i]);
var value = typeName;
if (metadata.isNotEmpty) {
   ...
}
...

[vsm, 2015/08/07 17:07:32]

Done.

+      var metadata = parameter != null
+          ? parameter is NormalFormalParameter
+              ? parameter.metadata
+              : (parameter as DefaultFormalParameter).parameter.metadata

[Jennifer Messerly, 2015/07/24 16:28:28]

hmm, this might be good feedback to analyzer. Would a forwarder help?
I'm happy to send a CL over to them. We're going to depend on 0.26-alpha soon
anyway (needed a bug fix to ResolutionCopier for AwaitExpression)

[vsm, 2015/08/07 17:07:32]

Factored it out a bit to a helper here.  A forwarder sounds good - you still
hacking that code?

+          : [];
+      var typeName = _emitTypeName(types[i]);
+      var value = typeName;
+      if (metadata.isNotEmpty) {
+        metadata = metadata.map(_instantiateAnnotation).toList();
+        value = new JS.ArrayInitializer([typeName]..addAll(metadata));
+      }
+      result.add(value);
+    }
+    return new JS.ArrayInitializer(result);
   }
 
   JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types) {
@@ -1402,21 +1419,27 @@ class JSCodegenVisitor extends GeneralizingAstVisitor {
 
   /// Emit the pieces of a function type, as an array of return type,
   /// regular args, and optional/named args.
-  List<JS.Expression> _emitFunctionTypeParts(FunctionType type) {
+  List<JS.Expression> _emitFunctionTypeParts(FunctionType type,
+      [FormalParameterList parameterList]) {
+    List<FormalParameter> parameters =

[Jennifer Messerly, 2015/07/24 16:28:28]

should this be:

    var parameters = parameterList?.parameters;

[vsm, 2015/08/07 17:07:32]

Done.

+        parameterList != null ? parameterList.parameters : null;
     var returnType = type.returnType;
     var parameterTypes = type.normalParameterTypes;
     var optionalTypes = type.optionalParameterTypes;
     var namedTypes = type.namedParameterTypes;
     var rt = _emitTypeName(returnType);
-    var ra = _emitTypeNames(parameterTypes);
+    var ra = _emitTypeNames(parameterTypes, parameters);
     if (!namedTypes.isEmpty) {
       assert(optionalTypes.isEmpty);
+      // TODO(vsm): Pass in annotations here as well.
       var na = _emitTypeProperties(namedTypes);
       return [rt, ra, na];
     }
     if (!optionalTypes.isEmpty) {
       assert(namedTypes.isEmpty);
-      var oa = _emitTypeNames(optionalTypes);
+      var oa = _emitTypeNames(optionalTypes, parameters != null

[Jennifer Messerly, 2015/07/24 16:28:28]

ditto:

    parameters?.sublist(parameterTypes.length)


FWIW, I'm considering a tool that will auto fix these. But might be nice to have
a few landed by hand, so we work out any kinks it causes :)

[vsm, 2015/08/07 17:07:32]

Done.

+          ? parameters.sublist(parameterTypes.length)
+          : null);
       return [rt, ra, oa];
     }
     return [rt, ra];
@@ -1601,10 +1624,11 @@ class JSCodegenVisitor extends GeneralizingAstVisitor {
     if (DynamicInvoke.get(target)) {
       code = 'dart.$DSEND(#, #, #)';
     } else if (DynamicInvoke.get(node.methodName)) {
-      // This is a dynamic call to a statically know target. For example:
+      // This is a dynamic call to a statically known target. For example:
       //     class Foo { Function bar; }
       //     new Foo().bar(); // dynamic call
       code = 'dart.$DCALL(#.#, #)';
+      // code = 'dart.$DSEND(#, #, #)';

[Jennifer Messerly, 2015/07/24 16:28:28]

remove commented code?

[vsm, 2015/08/07 17:07:32]

Done.

[vsm, 2015/08/07 17:07:32]

Done.

     } else if (_requiresStaticDispatch(target, name)) {
       assert(rules.objectMembers[name] is FunctionType);
       // Object methods require a helper for null checks.