Compile package:js.{rest, spread} helpers

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 13 matching lines @@
 import '../js/js_ast.dart' show js;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../compiler.dart' show AbstractCompiler;
 import '../info.dart';
 import '../options.dart' show CodegenOptions;
 import '../utils.dart';
 
 import 'code_generator.dart';
 import 'js_field_storage.dart';
+import 'js_interop.dart';
 import 'js_names.dart' as JS;
 import 'js_metalet.dart' as JS;
 import 'js_module_item_order.dart';
 import 'js_printer.dart' show writeJsLibrary;
 import 'side_effect_analysis.dart';
 
 // Various dynamic helpers we call.
 // If renaming these, make sure to check other places like the
 // _runtime.js file and comments.
 // TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
@@ skipping 196 matching lines @@
     if (node is! FunctionDeclaration) _flushLibraryProperties(_moduleItems);
 
     var code = _visit(node);
     if (code != null) _moduleItems.add(code);
   }
 
   @override
   void visitLibraryDirective(LibraryDirective node) {
     assert(_jsModuleValue == null);
 
-    var jsName = findAnnotation(node.element, _isJsNameAnnotation);
+    var jsName = findAnnotation(node.element, isJsNameAnnotation);
     _jsModuleValue =
         getConstantField(jsName, 'name', types.stringType)?.toStringValue();
   }
 
   @override
   void visitImportDirective(ImportDirective node) {
     // Nothing to do yet, but we'll want to convert this to an ES6 import once
     // we have support for modules.
   }
 
@@ skipping 152 matching lines @@
       if (isPublic(dartClassName)) _addExport(dartClassName);
       return js.statement('let # = #;', [dartClassName, jsTypeName]);
     }
     return null;
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
     var classElem = node.element;
     var type = classElem.type;
-    var jsName = findAnnotation(classElem, _isJsNameAnnotation);
+    var jsName = findAnnotation(classElem, isJsNameAnnotation);
 
     if (jsName != null) return _emitJsType(node.name.name, jsName);
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var methods = <MethodDeclaration>[];
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration && !member.isStatic) {
         fields.add(member);
       } else if (member is MethodDeclaration) {
         methods.add(member);
       }
     }
 
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _classHeritage(classElem), _emitClassMethods(node, ctors, fields));
 
     String jsPeerName;
-    var jsPeer = findAnnotation(classElem, _isJsPeerInterface);
+    var jsPeer = findAnnotation(classElem, isJsPeerInterface);
     if (jsPeer != null) {
       jsPeerName =
           getConstantField(jsPeer, 'name', types.stringType)?.toStringValue();
     }
 
     var body = _finishClassMembers(classElem, classExpr, ctors, fields, methods,
         node.metadata, jsPeerName);
 
     var result = _finishClassDef(type, body);
 
@@ skipping 134 matching lines @@
     var type = element.type;
     var isObject = type.isObject;
 
     // Iff no constructor is specified for a class C, it implicitly has a
     // default constructor `C() : super() {}`, unless C is class Object.
     var jsMethods = <JS.Method>[];
     if (ctors.isEmpty && !isObject) {
       jsMethods.add(_emitImplicitConstructor(node, fields));
     }
 
-    bool hasJsPeer = findAnnotation(element, _isJsPeerInterface) != null;
+    bool hasJsPeer = findAnnotation(element, isJsPeerInterface) != null;
 
     bool hasIterator = false;
     for (var m in node.members) {
       if (m is ConstructorDeclaration) {
         jsMethods.add(_emitConstructor(m, type, fields, isObject));
       } else if (m is MethodDeclaration) {
         jsMethods.add(_emitMethodDeclaration(type, m));
 
         if (!hasJsPeer && m.isGetter && m.name.name == 'iterator') {
           hasIterator = true;
@@ skipping 1236 matching lines @@
     return js.call(code, [_visit(node.function), _visit(node.argumentList)]);
   }
 
   @override
   List<JS.Expression> visitArgumentList(ArgumentList node) {
     var args = <JS.Expression>[];
     var named = <JS.Property>[];
     for (var arg in node.arguments) {
       if (arg is NamedExpression) {
         named.add(_visit(arg));
+      } else if (arg is MethodInvocation && isJsSpreadInvocation(arg)) {
+        args.add(
+            new JS.RestParameter(_visit(arg.argumentList.arguments.single)));
       } else {
         args.add(_visit(arg));
       }
     }
     if (named.isNotEmpty) {
       args.add(new JS.ObjectInitializer(named));
     }
     return args;
   }
 
   @override
   JS.Property visitNamedExpression(NamedExpression node) {
     assert(node.parent is ArgumentList);
     return new JS.Property(
         _propertyName(node.name.label.name), _visit(node.expression));
   }
 
   @override
-  List<JS.Identifier> visitFormalParameterList(FormalParameterList node) {
-    var result = <JS.Identifier>[];
+  List<JS.Parameter> visitFormalParameterList(FormalParameterList node) {
+    var result = <JS.Parameter>[];
     for (FormalParameter param in node.parameters) {
       if (param.kind == ParameterKind.NAMED) {
         result.add(_namedArgTemp);
         break;
       }
       result.add(_visit(param));
     }
     return result;
   }
 
@@ skipping 626 matching lines @@
     _cascadeTarget = savedCascadeTemp;
     return result;
   }
 
   @override
   visitParenthesizedExpression(ParenthesizedExpression node) =>
       // The printer handles precedence so we don't need to.
       _visit(node.expression);
 
   @override
-  visitFormalParameter(FormalParameter node) =>
-      visitSimpleIdentifier(node.identifier);
+  visitFormalParameter(FormalParameter node) {
+    var id = visitSimpleIdentifier(node.identifier);
+
+    var isRestArg = findAnnotation(node.element, isJsRestAnnotation) != null;
+    return isRestArg ? new JS.RestParameter(id) : id;
+  }
 
   @override
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
 
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (isLibraryPrefix(node.prefix)) {
@@ skipping 141 matching lines @@
     var target = _getTarget(node);
     if (_useNativeJsIndexer(target.staticType)) {
       return new JS.PropertyAccess(_visit(target), _visit(node.index));
     }
     return _emitSend(target, '[]', [node.index]);
   }
 
   // TODO(jmesserly): ideally we'd check the method and see if it is marked
   // `external`, but that doesn't work because it isn't in the element model.
   bool _useNativeJsIndexer(DartType type) =>
-      findAnnotation(type.element, _isJsNameAnnotation) != null;
+      findAnnotation(type.element, isJsNameAnnotation) != null;
 
   /// Gets the target of a [PropertyAccess], [IndexExpression], or
   /// [MethodInvocation]. These three nodes can appear in a [CascadeExpression].
   Expression _getTarget(node) {
     assert(node is IndexExpression ||
         node is PropertyAccess ||
         node is MethodInvocation);
     return node.isCascaded ? _cascadeTarget : node.target;
   }
 
@@ skipping 598 matching lines @@
 /// This never uses the library's name (the identifier in the `library`
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(LibraryElement library) => canonicalLibraryName(library);
 
 /// Shorthand for identifier-like property names.
 /// For now, we emit them as strings and the printer restores them to
 /// identifiers if it can.
 // TODO(jmesserly): avoid the round tripping through quoted form.
 JS.LiteralString _propertyName(String name) => js.string(name, "'");
 
-// TODO(jmesserly): validate the library. See issue #135.
-bool _isJsNameAnnotation(DartObject value) => value.type.name == 'JsName';
-
-bool _isJsPeerInterface(DartObject value) =>
-    value.type.name == 'JsPeerInterface';
-
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;
 
 /// 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);
 }