Implement more of dart:mirrors

lib/src/codegen/js_codegen.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 dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 446 matching lines @@
 
     // Create static values list
     var values = new JS.ArrayInitializer(new List<JS.Expression>.from(
         fields.map((f) => js.call('#.#', [id, f.name]))));
     result.add(js.statement('#.values = dart.const(dart.list(#, #));', [
       id,
       values,
       _emitTypeName(type)
     ]));
 
+    if (isPublic(type.name)) _addExport(type.name);
     return _statement(result);
   }
 
   /// Given a class element and body, complete the class declaration.
   /// This handles generic type parameters, laziness (in library-cycle cases),
   /// and ensuring dependencies are loaded first.
   JS.Statement _finishClassDef(ParameterizedType type, JS.Statement body) {
     var name = type.name;
     var genericName = '$name\$';
 
@@ skipping 233 matching lines @@
           } else {
             tMethods.add(property);
           }
         }
       }
 
       var tCtors = <JS.Property>[];
       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);
       }
 
       JS.Property build(String name, List<JS.Property> elements) {
         var o =
             new JS.ObjectInitializer(elements, multiline: elements.length > 1);
         var e = js.call('() => #', o);
         return new JS.Property(_propertyName(name), e);
@@ skipping 647 matching lines @@
         return _getTemp(element, name);
       }
     }
 
     return new JS.Identifier(name);
   }
 
   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) {
     var properties = <JS.Property>[];
     types.forEach((name, type) {
       var key = _propertyName(name);
       var value = _emitTypeName(type);
       properties.add(new JS.Property(key, value));
     });
     return new JS.ObjectInitializer(properties);
   }
 
   /// 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];
   }
 
   JS.Expression _emitFunctionRTTI(FunctionType type) {
     var parts = _emitFunctionTypeParts(type);
     return js.call('dart.definiteFunctionType(#)', [parts]);
   }
 
@@ skipping 164 matching lines @@
 
     var type = getStaticType(target);
     var name = node.methodName.name;
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
     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.
       return js.call('dart.#(#, #)', [
         memberName,
         _visit(target),
         _visit(node.argumentList)
       ]);
     } else {
       code = '#.#(#)';
@@ skipping 1244 matching lines @@
 
 class _JsThisFinder extends JS.BaseVisitor {
   bool found = false;
   visitThis(JS.This node) {
     found = true;
   }
   visitNode(JS.Node node) {
     if (!found) super.visitNode(node);
   }
 }