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 491 matching lines @@
       result.add(js.statement('#.# = dart.const(new #(#));',
           [id, fields[i].name, id, js.number(i)]));
     }
 
     // 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 222 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 22 matching lines @@
       var methodNames = <JS.Expression>[];
       for (var e in extensions) {
         methodNames.add(_elementMemberName(e));
       }
       body.add(js.statement('dart.defineExtensionMembers(#, #);', [
         name,
         new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
       ]));
     }
 
+    // TODO(vsm): Make this optional per #268.
     // Metadata
     if (metadata.isNotEmpty) {
       body.add(js.statement('#[dart.metadata] = () => #;', [
         name,
         new JS.ArrayInitializer(
             new List<JS.Expression>.from(metadata.map(_instantiateAnnotation)))
       ]));
     }
 
     return _statement(body);
@@ skipping 665 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)));
+  List<Annotation> _parameterMetadata(FormalParameter p) =>
+      (p is NormalFormalParameter)
+          ? p.metadata
+          : (p as DefaultFormalParameter).parameter.metadata;
+
+  JS.ArrayInitializer _emitTypeNames(List<DartType> types,
+      [List<FormalParameter> parameters]) {
+    var result = <JS.Expression>[];
+    for (int i = 0; i < types.length; ++i) {
+      var metadata =
+          parameters != null ? _parameterMetadata(parameters[i]) : [];
+      var typeName = _emitTypeName(types[i]);
+      var value = typeName;
+      // TODO(vsm): Make this optional per #268.
+      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]) {
+    var parameters = parameterList?.parameters;
     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?.sublist(parameterTypes.length));
       return [rt, ra, oa];
     }
     return [rt, ra];
   }
 
   JS.Expression _emitFunctionRTTI(FunctionType type) {
     var parts = _emitFunctionTypeParts(type);
     return js.call('dart.definiteFunctionType(#)', [parts]);
   }
 
@@ skipping 163 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(#.#, #)';
     } 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 1342 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }