Split Parameter and TypeParameter out of Identifier

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 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 448 matching lines @@
       // want to support construction of instances with generic types other
       // than dynamic. See issue #154 for Array and List<E> related bug.
       var copyMembers = js.statement(
           'dart.registerExtension(dart.global.#, #);',
           [_propertyName(jsPeerName), classElem.name]);
       return _statement([result, copyMembers]);
     }
     return result;
   }
 
-  Iterable<JS.Identifier> _emitTypeParams(TypeParameterizedElement e) sync* {
+  Iterable<JS.TypeParameter> _emitTypeParams(TypeParameterizedElement e) sync* {
     if (!options.closure) return;
     for (var typeParam in e.typeParameters) {
-      yield new JS.Identifier(typeParam.name);
+      yield new JS.TypeParameter(
+          new JS.Identifier(typeParam.name),
+          bound: emitTypeRef(typeParam.bound));
     }
   }
 
   /// Emit field declarations for TypeScript & Closure's ES6_TYPED
   /// (e.g. `class Foo { i: string; }`)
   Iterable<JS.VariableDeclarationList> _emitFieldDeclarations(
       ClassElement classElem,
       List<FieldDeclaration> fields,
       List<FieldDeclaration> staticFields) sync* {
     if (!options.closure) return;
 
     makeInitialization(VariableDeclaration decl) =>
         new JS.VariableInitialization(
-            new JS.Identifier(
-                // TODO(ochafik): use a refactored _emitMemberName instead.
-                decl.name.name,
-                type: emitTypeRef(decl.element.type)),
-            null);
+            // TODO(ochafik): use a refactored _emitMemberName instead.
+            new JS.Identifier(decl.name.name),
+            null,
+            type: emitTypeRef(decl.element.type));
 
     for (var field in fields) {
       yield new JS.VariableDeclarationList(
           null, field.fields.variables.map(makeInitialization).toList());
     }
     for (var field in staticFields) {
       yield new JS.VariableDeclarationList(
           'static', field.fields.variables.map(makeInitialization).toList());
     }
   }
@@ skipping 703 matching lines @@
           fields[element as FieldElement] = _visitInitializer(fieldNode);
         }
       }
     }
 
     // Initialize fields from `this.fieldName` parameters.
     if (ctor != null) {
       for (var p in ctor.parameters.parameters) {
         var element = p.element;
         if (element is FieldFormalParameterElement) {
-          fields[element.field] = _emitFormalParameter(p, allowType: false);
+          fields[element.field] = _visit(p.identifier);
         }
       }
 
       // Run constructor field initializers such as `: foo = bar.baz`
       for (var init in ctor.initializers) {
         if (init is ConstructorFieldInitializer) {
           fields[init.fieldName.staticElement as FieldElement] =
               _visit(init.expression);
         }
       }
@@ skipping 37 matching lines @@
   JS.Statement _emitArgumentInitializers(node, {bool constructor: false}) {
     // Constructor argument initializers are emitted earlier in the code, rather
     // than always when we visit the function body, so we control it explicitly.
     if (node is ConstructorDeclaration != constructor) return null;
 
     var parameters = _parametersOf(node);
     if (parameters == null) return null;
 
     var body = <JS.Statement>[];
     for (var param in parameters.parameters) {
-      var jsParam = _emitSimpleIdentifier(param.identifier, allowType: false);
+      var jsParam = _visit(param.identifier);
 
       if (param.kind == ParameterKind.NAMED) {
         if (!options.destructureNamedParams) {
           // Parameters will be passed using their real names, not the (possibly
           // renamed) local variable.
           var paramName = js.string(param.identifier.name, "'");
 
           // TODO(ochafik): Fix `'prop' in obj` to please Closure's renaming.
           body.add(js.statement('let # = # && # in # ? #.# : #;', [
             jsParam,
@@ skipping 46 matching lines @@
     if (params == null) params = <JS.Parameter>[];
 
     var typeParams = _emitTypeParams(node.element).toList();
     var returnType = emitTypeRef(node.element.returnType);
     JS.Fun fn = _emitFunctionBody(params, node.body, typeParams, returnType);
     if (node.operatorKeyword != null &&
         node.name.name == '[]=' &&
         params.isNotEmpty) {
       // []= methods need to return the value. We could also address this at
       // call sites, but it's cleaner to instead transform the operator method.
-      var returnValue = new JS.Return(params.last);
+      // TODO(ochafik): How do we ensure this is an expression and not a destructing pattern?
+      var returnValue = new JS.Return(params.last.binding as JS.Expression);
       var body = fn.body;
       if (JS.Return.foundIn(fn)) {
         // If a return is inside body, transform `(params) { body }` to
         // `(params) { (() => { body })(); return value; }`.
         // TODO(jmesserly): we could instead generate the return differently,
         // and avoid the immediately invoked function.
         body = new JS.Call(new JS.ArrowFun([], fn.body), []).toStatement();
       }
       // Rewrite the function to include the return.
       fn = new JS.Fun(fn.params, new JS.Block([body, returnValue]),
@@ skipping 186 matching lines @@
       if (!inStmt) {
         var type = getStaticType(node);
         return _emitFunctionTagged(clos, type,
             topLevel: _executesAtTopLevel(node));
       }
       return clos;
     }
   }
 
   JS.Fun _emitFunctionBody(List<JS.Parameter> params, FunctionBody body,
-      List<JS.Identifier> typeParams, JS.TypeRef returnType) {
+      List<JS.TypeParameter> typeParams, JS.TypeRef returnType) {
     // sync*, async, async*
     if (body.isAsynchronous || body.isGenerator) {
       return new JS.Fun(
           params,
           js.statement('{ return #; }',
               [_emitGeneratorFunctionBody(params, body, returnType)]),
           returnType: returnType);
     }
     // normal function (sync)
     return new JS.Fun(params, _visit(body),
@@ skipping 77 matching lines @@
       declareFn = new JS.FunctionDeclaration(name, fn);
     }
     declareFn = annotate(declareFn, node, node.functionDeclaration.element);
 
     return new JS.Block([
       declareFn,
       _emitFunctionTagged(name, func.element.type).toStatement()
     ]);
   }
 
-  @override
-  JS.Expression visitSimpleIdentifier(SimpleIdentifier node) =>
-      _emitSimpleIdentifier(node);
-
   /// Writes a simple identifier. This can handle implicit `this` as well as
   /// going through the qualified library name if necessary.
-  JS.Expression _emitSimpleIdentifier(SimpleIdentifier node,
-      {bool allowType: false}) {
+  @override
+  JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var accessor = node.staticElement;
     if (accessor == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (accessor is PropertyAccessorElement) element = accessor.variable;
@@ skipping 48 matching lines @@
     }
 
     if (element is TemporaryVariableElement) {
       if (name[0] == '#') {
         return new JS.InterpolatedExpression(name.substring(1));
       } else {
         return _getTemp(element, name);
       }
     }
 
-    return annotate(
-        new JS.Identifier(name,
-            type: allowType ? emitTypeRef(node.bestType) : null),
-        node);
+    return annotate(new JS.Identifier(name), node);
   }
 
   JS.TemporaryId _getTemp(Element key, String name) =>
       _temps.putIfAbsent(key, () => new JS.TemporaryId(name));
 
   List<Annotation> _parameterMetadata(FormalParameter p) =>
       (p is NormalFormalParameter)
           ? p.metadata
           : (p as DefaultFormalParameter).parameter.metadata;
 
@@ skipping 354 matching lines @@
       code = '#(#)';
     }
     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) {
+      var jsArg = _visit(arg);
       if (arg is NamedExpression) {
-        named.add(_visit(arg));
+        named.add(jsArg);
       } else if (arg is MethodInvocation && isJsSpreadInvocation(arg)) {
-        args.add(
-            new JS.RestParameter(_visit(arg.argumentList.arguments.single)));
+        args.add(new JS.Spread(jsArg));
       } else {
-        args.add(_visit(arg));
+        args.add(jsArg);
       }
     }
     if (named.isNotEmpty) {
       args.add(new JS.ObjectInitializer(named));
     }
     return args;
   }
 
   @override
   JS.Property visitNamedExpression(NamedExpression node) {
@@ skipping 34 matching lines @@
             name = _visit(param.identifier);
           }
           namedVars.add(new JS.DestructuredVariable(
               name: name,
               structure: structure,
               defaultValue: _defaultParamValue(param)));
         } else {
           needsOpts = true;
         }
       } else {
-        var jsParam = _visit(param);
-        result.add(
-            param is DefaultFormalParameter && options.destructureNamedParams
-                ? new JS.DestructuredVariable(
-                    name: jsParam, defaultValue: _defaultParamValue(param))
-                : jsParam);
+        result.add(_visit(param));
       }
     }
 
     if (needsOpts) {
-      result.add(_namedArgTemp);
+      result.add(new JS.Parameter(_namedArgTemp));
     } else if (namedVars.isNotEmpty) {
       // Note: `var {valueOf} = {}` extracts `Object.prototype.valueOf`, so
       // in case there are conflicting names we create an object without
       // any prototype.
       var defaultOpts = hasNamedArgsConflictingWithObjectProperties
           ? js.call('Object.create(null)')
           : js.call('{}');
-      result.add(new JS.DestructuredVariable(
-          structure: new JS.ObjectBindingPattern(namedVars),
+      result.add(new JS.Parameter(
+          new JS.ObjectBindingPattern(namedVars),
           type: emitNamedParamsArgType(node.parameterElements),
           defaultValue: defaultOpts));
     }
     return result;
   }
 
   /// See ES6 spec (and `Object.getOwnPropertyNames(Object.prototype)`):
   /// http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-object-prototype-object
   /// http://www.ecma-international.org/ecma-262/6.0/#sec-additional-properties-of-the-object.prototype-object
   static final Set<String> _jsObjectProperties = new Set<String>()
@@ skipping 112 matching lines @@
   }
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
     if (node.element is PropertyInducingElement) {
       // Static and instance fields are handled elsewhere.
       assert(node.element is TopLevelVariableElement);
       return _emitTopLevelField(node);
     }
 
-    var name =
-        new JS.Identifier(node.name.name, type: emitTypeRef(node.element.type));
-    return new JS.VariableInitialization(name, _visitInitializer(node));
+    var name = new JS.Identifier(node.name.name);
+    return new JS.VariableInitialization(name, _visitInitializer(node),
+        type: emitTypeRef(node.element.type));
   }
 
   bool _isFinalJSDecl(AstNode field) =>
       field is VariableDeclaration &&
       field.isFinal &&
       _isJSInvocation(field.initializer);
 
   /// Try to emit a constant static field.
   ///
   /// If the field's initializer does not cause side effects, and if all of
@@ skipping 72 matching lines @@
       // constant fields don't change, so we can generate them as `let`
       // but add them to the module's exports. However, make sure we generate
       // anything they depend on first.
 
       if (isPublic(fieldName)) _addExport(fieldName, exportName);
       var declKeyword = field.isConst || field.isFinal ? 'const' : 'let';
       return js.statement('#;', [
         annotate(
             new JS.VariableDeclarationList(declKeyword, [
               new JS.VariableInitialization(
-                  new JS.Identifier(fieldName,
-                      type: emitTypeRef(field.element.type)),
-                  jsInit)
+                  new JS.Identifier(fieldName),
+                  jsInit,
+                  type: emitTypeRef(field.element.type))
             ]),
             field,
             field.element)
       ]);
     }
 
     if (eagerInit && !JS.invalidStaticFieldName(fieldName)) {
       return annotate(js.statement('# = #;', [_visit(field.name), jsInit]),
           field, field.element);
     }
@@ skipping 411 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) => _emitFormalParameter(node);
-
-  _emitFormalParameter(FormalParameter node, {bool allowType: true}) {
-    var id = _emitSimpleIdentifier(node.identifier, allowType: allowType);
-
-    var isRestArg = findAnnotation(node.element, isJsRestAnnotation) != null;
-    return isRestArg ? new JS.RestParameter(id) : id;
+  visitFormalParameter(FormalParameter node) {
+    var defaultValue =
+        node is DefaultFormalParameter && options.destructureNamedParams
+            ? _defaultParamValue(node) : null;
+    return new JS.Parameter(
+        _visit(node.identifier),
+        type: emitTypeRef(node.element.type),
+        defaultValue: defaultValue,
+        isRest: findAnnotation(node.element, isJsRestAnnotation) != null);
   }
 
   @override
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
 
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
@@ skipping 832 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);
 }