Add @jsify annotation. Support automatically proxying Lists and Maps to Dart in Proxies. Support co…

lib/src/transformer/js_proxy_generator.dart

 // Copyright (c) 2014, 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 js.transformer.js_proxy_generator;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:barback/barback.dart';
 import 'package:js/src/metadata.dart';
 import 'package:js/src/transformer/utils.dart';
 import 'package:logging/logging.dart';
 import 'package:quiver/iterables.dart' show max, concat;
 import 'package:source_maps/refactor.dart';
 
 final _logger = new Logger('js.transformer.js_proxy_generator');
 
 const JS_PREFIX = '__package_js_impl__';
 
 class JsProxyGenerator {
   final AssetId inputId;
   final ClassElement jsInterfaceClass;
   final ClassElement jsProxyClass;
   final ClassElement exportClass;
   final ClassElement noExportClass;
+  final ClassElement jsifyClass;
 
   final LibraryElement library;
   final LibraryElement jsLibrary;
   final TextEditTransaction transaction;
 
   /// The list of classes to generate proxy implementations for
   final Iterable<ClassElement> jsProxies;
   final InheritanceManager inheritanceManager;
 
   var generatedMembers = new Set<Element>();
 
   JsProxyGenerator(
     this.inputId,
     this.jsProxies,
     LibraryElement library,
     LibraryElement jsLibrary,
     LibraryElement jsMetadataLibrary,
     this.transaction)
       : library = library,
         jsLibrary = jsLibrary,
         jsInterfaceClass = getImplLib(jsLibrary).getType('JsInterface'),
         jsProxyClass = jsMetadataLibrary.getType('JsProxy'),
         exportClass = jsMetadataLibrary.getType('Export'),
         noExportClass = jsMetadataLibrary.getType('NoExport'),
+        jsifyClass = jsMetadataLibrary.getType('Jsify'),
         inheritanceManager = new InheritanceManager(library) {
     assert(jsLibrary != null);
     assert(library != null);
     assert(jsInterfaceClass != null);
     assert(jsProxyClass != null);
     assert(exportClass != null);
     assert(noExportClass != null);
   }
 
   /**
@@ skipping 125 matching lines @@
       }
     }
 
   }
 
   void _generateMethod(MethodElement a) {
     var name = a.displayName;
     if (!a.isStatic) {
       var returnType = a.returnType;
 
-      var jsParameterList = new StringBuffer();
+      var jsArgs = new List(a.parameters.length);
 
-      var parameterList = a.parameters
-          .map((p) => '$JS_PREFIX.toJs(${p.name})')
-          .join(', ');
+      for (int i = 0; i < a.parameters.length; i++) {
+        var param = a.parameters[i];
+        var hasJsify = hasAnnotation(param, jsifyClass);
+        if (hasJsify) {
+          jsArgs[i] = '$JS_PREFIX.jsify(${param.name})';
+        } else {
+          jsArgs[i] = '$JS_PREFIX.toJs(${param.name})';
+        }
+      }
+
+      var parameterList = jsArgs.join(', ');
 
       MethodDeclaration m = a.node;
       var offset = m.body.offset;
       var end = m.body.end;
       if (a.returnType.name == 'void') {
         transaction.edit(offset, end, " { $JS_PREFIX.toDart("
             "$JS_PREFIX.toJs(this).callMethod('$name', [$parameterList])); }");
       } else {
         transaction.edit(offset, end, " => $JS_PREFIX.toDart("
-            "$JS_PREFIX.toJs(this).callMethod('$name', [$parameterList]))"
-            " as ${a.returnType};");
+            "$JS_PREFIX.toJs(this).callMethod('$name', [$parameterList]), "
+            "#${returnType.name}) as ${a.returnType};");
       }
     }
   }
 
   void _generateSetter(PropertyAccessorElement a) {
     var name = a.displayName;
     var parameter = a.parameters.single;
     var type = parameter.type;
     if (type == null) {
       _logger.severe("abstract JsInterface setters must have type annotations");
@@ skipping 28 matching lines @@
   ConstructorElement _checkCreatedConstructor(ClassElement interface) =>
       interface.constructors.firstWhere(
           (c) => c.name == 'created' && !c.isFactory,
           orElse: () {
             _logger.severe("JsInterface subclasses must have a"
                 "generative constructor named 'created'");
             return null;
           });
 
 }