[js_ast] adds Identifier that merges VariableDeclaration/Use and Parameter

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;
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 241 matching lines @@
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     // If we've already emitted this class, skip it.
     var classElem = node.element;
     if (_pendingClasses.remove(classElem) == null) return null;
 
     var name = node.name.name;
     var heritage =
         js.call('dart.mixin(#)', [_visitList(node.withClause.mixinTypes)]);
     var classDecl = new JS.ClassDeclaration(
-        new JS.ClassExpression(new JS.VariableDeclaration(name), heritage, []));
+        new JS.ClassExpression(new JS.Identifier(name), heritage, []));
 
     return _finishClassDef(classElem, classDecl);
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
     // If we've already emitted this class, skip it.
     var classElem = node.element;
     if (_pendingClasses.remove(classElem) == null) return null;
     if (_getJsNameAnnotation(node) != null) return null;
 
     currentClass = node;
 
     var name = classElem.name;
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var staticFields = <FieldDeclaration>[];
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration) {
         (member.isStatic ? staticFields : fields).add(member);
       }
     }
 
-    var classExpr = new JS.ClassExpression(new JS.VariableDeclaration(name),
+    var classExpr = new JS.ClassExpression(new JS.Identifier(name),
         _classHeritage(node), _emitClassMethods(node, ctors, fields));
 
     var body = _finishClassMembers(name, classExpr, ctors, staticFields);
     currentClass = null;
 
     return _finishClassDef(classElem, body);
   }
 
   @override
   JS.Statement visitEnumDeclaration(EnumDeclaration node) =>
@@ skipping 155 matching lines @@
     for (var e in library.exports) {
       if (result) break;
       result = _inLibraryCycle(e.exportedLibrary);
     }
     return _libraryCycleMemo[library] = result;
   }
 
   JS.Statement _emitGenericClassDef(ClassElement cls, JS.Statement body) {
     var name = cls.name;
     var genericName = '$name\$';
-    var typeParams = cls.typeParameters.map((p) => new JS.Parameter(p.name));
+    var typeParams = cls.typeParameters.map((p) => p.name);
     return js.statement('let # = dart.generic(function(#) { #; return #; });', [
       genericName,
       typeParams,
       body,
       name
     ]);
   }
 
   JS.Expression _classHeritage(ClassDeclaration node) {
     if (node.element.type.isObject) return null;
@@ skipping 378 matching lines @@
       return null;
     }
 
     var body = <JS.Statement>[];
     _flushLibraryProperties(body);
 
     var name = node.name.name;
     body.add(js.comment('Function $name: ${node.element.type}'));
 
     body.add(new JS.FunctionDeclaration(
-        new JS.VariableDeclaration(name), _visit(node.functionExpression)));
+        new JS.Identifier(name), _visit(node.functionExpression)));
 
     if (isPublic(name)) _exports.add(name);
     return _statement(body);
   }
 
   JS.Method _emitTopLevelProperty(FunctionDeclaration node) {
     var name = node.name.name;
     return new JS.Method(_propertyName(name), _visit(node.functionExpression),
         isGetter: node.isGetter, isSetter: node.isSetter);
   }
@@ skipping 23 matching lines @@
   }
 
   @override
   JS.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var func = node.functionDeclaration;
     if (func.isGetter || func.isSetter) {
       return js.comment('Unimplemented function get/set statement: $node');
     }
 
-    var name = new JS.VariableDeclaration(func.name.name);
+    var name = new JS.Identifier(func.name.name);
     return new JS.Block([
       js.comment("// Function ${func.name.name}: ${func.element.type}\n"),
       new JS.FunctionDeclaration(name, _visit(func.functionExpression))
     ]);
   }
 
   /// Writes a simple identifier. This can handle implicit `this` as well as
   /// going through the qualified library name if necessary.
   @override
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var e = node.staticElement;
     if (e == null) {
       return js.commentExpression(
-          'Unimplemented unknown name', new JS.VariableUse(node.name));
+          'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     var name = node.name;
     var variable = e is PropertyAccessorElement ? e.variable : e;
 
     if (e.enclosingElement is CompilationUnitElement &&
         (e.library != libraryInfo.library ||
             variable is TopLevelVariableElement && !variable.isConst)) {
       return js.call('#.#', [_libraryName(e.library), name]);
     } else if (currentClass != null && _needsImplicitThis(e)) {
       return js.call('this.#', _jsMemberName(name));
     } else if (variable is ConstFieldElementImpl) {
       var className = (variable.enclosingElement as ClassElement).name;
       return js.call('#.#', [className, name]);
     } else if (e is ParameterElement && e.isInitializingFormal) {
       name = _fieldParameterName(name);
     }
-    return new JS.VariableUse(name);
+    return new JS.Identifier(name);
   }
 
   JS.Expression _emitTypeName(DartType type) {
     var name = type.name;
     var element = type.element;
     if (name == '') {
       // TODO(jmesserly): remove when we're using coercion reifier.
       return _unimplementedCall('Unimplemented type $type');
     }
 
     var typeArgs = null;
     if (type is ParameterizedType) {
       // TODO(jmesserly): this is a workaround for an analyzer bug, see:
       // https://github.com/dart-lang/dev_compiler/commit/a212d59ad046085a626dd8d16881cdb8e8b9c3fa
       if (type is! FunctionType || element is FunctionTypeAlias) {
         var args = type.typeArguments;
         if (args.any((a) => a != rules.provider.dynamicType)) {
           name = '$name\$';
           typeArgs = args.map(_emitTypeName);
         }
       }
     }
 
     JS.Expression result;
     if (_needQualifiedName(element)) {
       result = js.call('#.#', [_libraryName(element.library), name]);
     } else {
-      result = new JS.VariableUse(name);
+      result = new JS.Identifier(name);
     }
 
     if (typeArgs != null) {
       result = js.call('#(#)', [result, typeArgs]);
     }
     return result;
   }
 
   bool _needQualifiedName(Element element) {
     var lib = element.library;
@@ skipping 172 matching lines @@
   }
 
   @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.Parameter> visitFormalParameterList(FormalParameterList node) {
-    var result = <JS.Parameter>[];
+  List<JS.Identifier> visitFormalParameterList(FormalParameterList node) {
+    var result = <JS.Identifier>[];
     for (FormalParameter param in node.parameters) {
       if (param.kind == ParameterKind.NAMED) {
-        result.add(new JS.Parameter(r'opt$'));
+        result.add(new JS.Identifier(r'opt$'));
         break;
       }
       result.add(_visit(param));
     }
     return result;
   }
 
   @override
   JS.Statement visitExpressionStatement(ExpressionStatement node) =>
       _expressionStatement(_visit(node.expression));
@@ skipping 21 matching lines @@
   @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     var body = <JS.Statement>[];
 
     for (var field in node.variables.variables) {
       if (field.isConst) {
         // constant fields don't change, so we can generate them as `let`
         // but add them to the module's exports
         var name = field.name.name;
         body.add(js.statement('let # = #;', [
-          new JS.VariableDeclaration(name),
+          new JS.Identifier(name),
           _visitInitializer(field)
         ]));
         if (isPublic(name)) _exports.add(name);
       } else if (_isFieldInitConstant(field)) {
         body.add(js.statement(
             '# = #;', [_visit(field.name), _visitInitializer(field)]));
       } else {
         _lazyFields.add(field);
       }
     }
@@ skipping 14 matching lines @@
       // We can reuse the variable to desugar it:
       //    var result = []..length = length;
       // becomes:
       //    var result = [];
       //    result.length = length;
       var savedCascadeTemp = _cascadeTarget;
       _cascadeTarget = last.name;
 
       variables = _visitList(node.variables.take(node.variables.length - 1));
       variables.add(new JS.VariableInitialization(
-          new JS.VariableDeclaration(last.name.name),
+          new JS.Identifier(last.name.name),
           _visit(lastInitializer.target)));
 
       var result =
           <JS.Expression>[new JS.VariableDeclarationList('let', variables)];
       result.addAll(_visitList(lastInitializer.cascadeSections));
       _cascadeTarget = savedCascadeTemp;
       return _statement(result.map((e) => new JS.ExpressionStatement(e)));
     } else {
       variables = _visitList(node.variables);
     }
 
     return new JS.VariableDeclarationList('let', variables);
   }
 
   @override
   JS.VariableInitialization visitVariableDeclaration(VariableDeclaration node) {
-    var name = new JS.VariableDeclaration(node.name.name);
+    var name = new JS.Identifier(node.name.name);
     return new JS.VariableInitialization(name, _visitInitializer(node));
   }
 
   JS.Expression _visitInitializer(VariableDeclaration node) {
     var value = _visit(node.initializer);
     // explicitly initialize to null, to avoid getting `undefined`.
     // TODO(jmesserly): do this only for vars that aren't definitely assigned.
     return value != null ? value : new JS.LiteralNull();
   }
 
@@ skipping 364 matching lines @@
     return false;
   }
 
   @override
   visitParenthesizedExpression(ParenthesizedExpression node) =>
       // The printer handles precedence so we don't need to.
       _visit(node.expression);
 
   @override
   visitFormalParameter(FormalParameter node) =>
-      new JS.Parameter(node.identifier.name);
+      new JS.Identifier(node.identifier.name);
 
   @override
   visitFieldFormalParameter(FieldFormalParameter node) =>
-      new JS.Parameter(_fieldParameterName(node.identifier.name));
+      new JS.Identifier(_fieldParameterName(node.identifier.name));
 
   /// Rename private names so they don't shadow the private field symbol.
   // TODO(jmesserly): replace this ad-hoc rename with a general strategy.
   _fieldParameterName(name) => name.startsWith('_') ? '\$$name' : name;
 
   @override
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
@@ skipping 129 matching lines @@
     _catchParameter = '\$e';
 
     if (clauses.length == 1) {
       // Special case for a single catch.
       var clause = clauses.single;
       if (clause.exceptionParameter != null) {
         _catchParameter = clause.exceptionParameter.name;
       }
     }
 
-    var catchVarDecl = new JS.VariableDeclaration(_catchParameter);
+    var catchVarDecl = new JS.Identifier(_catchParameter);
     var catchBody = new JS.Block(_visitList(clauses));
     _catchParameter = savedCatch;
 
     return new JS.Catch(catchVarDecl, catchBody);
   }
 
   JS.Statement _statement(Iterable stmts) {
     var s = stmts is List ? stmts : new List<JS.Statement>.from(stmts);
     // TODO(jmesserly): empty block singleton?
     if (s.length == 0) return new JS.Block([]);
     if (s.length == 1) return s[0];
     return new JS.Block(s);
   }
 
   @override
   JS.Statement visitCatchClause(CatchClause node) {
     var body = [];
 
     var savedCatch = _catchParameter;
     if (node.catchKeyword != null) {
       var name = node.exceptionParameter;
       if (name != null && name.name != _catchParameter) {
-        var decl = new JS.VariableDeclaration(name.name);
+        var decl = new JS.Identifier(name.name);
         decl.sourceInformation = name;
         body.add(js.statement('let # = #;', [decl, _catchParameter]));
         _catchParameter = name.name;
       }
       if (node.stackTraceParameter != null) {
         var stackVar = node.stackTraceParameter.name;
         body.add(js.statement(
             'let # = dart.stackTrace(#);', [stackVar, _visit(name)]));
       }
     }
@@ skipping 235 matching lines @@
   ///
   /// Unary minus looks like: `x['unary-']()`. Note that [unary] must be passed
   /// for this transformation to happen, otherwise binary minus is assumed.
   ///
   /// Equality is a bit special, it is generated via the Dart `equals` runtime
   /// helper, that checks for null. The user defined method is called '=='.
   ///
   JS.Expression _jsMemberName(String name, {bool unary: false}) {
     if (name.startsWith('_')) {
       if (_privateNames.add(name)) _pendingPrivateNames.add(name);
-      return new JS.VariableUse(name);
+      return new JS.Identifier(name);
     }
     if (name == '[]') {
       name = 'get';
     } else if (name == '[]=') {
       name = 'set';
     } else if (unary && name == '-') {
       name = 'unary-';
     }
     return _propertyName(name);
   }
@@ skipping 224 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }