more care around generated names, fixes #60 #82 and #97

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 11 matching lines @@
 
 // TODO(jmesserly): import from its own package
 import 'package:dev_compiler/src/js/js_ast.dart' as JS;
 import 'package:dev_compiler/src/js/js_ast.dart' show js;
 
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/report.dart';
 import 'package:dev_compiler/src/utils.dart';
+
 import 'code_generator.dart';
+import 'js_names.dart';
 
 bool _isAnnotationType(Annotation m, String name) => m.name.name == name;
 
 Annotation _getAnnotation(AnnotatedNode node, String name) => node.metadata
     .firstWhere((annotation) => _isAnnotationType(annotation, name),
         orElse: () => null);
 
 Annotation _getJsNameAnnotation(AnnotatedNode node) =>
     _getAnnotation(node, "JsName");
 
 class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
   final LibraryInfo libraryInfo;
   final TypeRules rules;
 
   // TODO(jmesserly): this is needed because RestrictedTypeRules can send
   // messages to CheckerReporter, for things like missing types.
   // We should probably refactor so this can't happen, as codegen would be too
   // late to be issuing these messages.
   final CheckerReporter _checkerReporter;
 
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
   /// The variable for the current catch clause
-  String _catchParameter;
+  SimpleIdentifier _catchParameter;
 
   ClassDeclaration currentClass;
   ConstantEvaluator _constEvaluator;
 
   final _exports = <String>[];
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
   final _privateNames = new HashSet<String>();
   final _pendingPrivateNames = <String>[];
 
   /// Classes we have not emitted yet. Values can be [ClassDeclaration] or
   /// [ClassTypeAlias].
   final _pendingClasses = new HashMap<ClassElement, CompilationUnitMember>();
 
   /// Memoized results of [_lazyClass].
   final _lazyClassMemo = new HashMap<ClassElement, bool>();
 
   /// Memoized results of [_inLibraryCycle].
   final _libraryCycleMemo = new HashMap<LibraryElement, bool>();
 
   JSCodegenVisitor(this.libraryInfo, this.rules, this._checkerReporter);
 
   LibraryElement get currentLibrary => libraryInfo.library;
 
+  /// The name for the library's exports inside itself.
+  /// This much be a constant because we interpolate it into template strings,
+  /// and otherwise it would break caching for them.
+  /// `exports` was chosen as the most similar to ES module patterns.
+  final JSTemporary _exportsVar = new JSTemporary('exports');
+  final JSTemporary _namedArgTemp = new JSTemporary('opts');
+
   JS.Program emitLibrary(LibraryUnit library) {
     var jsDefaultValue = '{}';
     var unit = library.library;
     if (unit.directives.isNotEmpty) {
       var annotation = _getJsNameAnnotation(unit.directives.first);
       if (annotation != null) {
         var arguments = annotation.arguments.arguments;
         if (!arguments.isEmpty) {
           var namedExpression = arguments.first as NamedExpression;
           var literal = namedExpression.expression as SimpleStringLiteral;
@@ skipping 15 matching lines @@
     }
 
     for (var unit in library.partsThenLibrary) body.add(_visit(unit));
 
     assert(_pendingClasses.isEmpty);
 
     if (_exports.isNotEmpty) body.add(js.comment('Exports:'));
 
     // TODO(jmesserly): make these immutable in JS?
     for (var name in _exports) {
-      body.add(js.statement('$_EXPORTS.# = #;', [name, name]));
+      body.add(js.statement('#.# = #;', [_exportsVar, name, name]));
     }
 
     var name = jsLibraryName(libraryInfo.library);
 
     var defaultValue = js.call(jsDefaultValue);
     return new JS.Program([
       js.statement('var #;', name),
-      js.statement("(function($_EXPORTS) { 'use strict'; #; })(# || (# = #));",
-          [body, name, name, defaultValue])
+      js.statement("(function(#) { 'use strict'; #; })(# || (# = #));", [
+        _exportsVar,
+        body,
+        name,
+        name,
+        defaultValue
+      ])
     ]);
   }
 
-  JS.Statement _initPrivateSymbol(String name) =>
-      js.statement('let # = $_SYMBOL(#);', [name, js.string(name, "'")]);
+  JS.Statement _initPrivateSymbol(String name) => js.statement(
+      'let # = $_SYMBOL(#);', [new JSTemporary(name), js.string(name, "'")]);
 
   // TODO(jmesserly): this is a temporary workaround for `Symbol` in core,
   // until we have better name tracking.
   String get _SYMBOL => currentLibrary.isDartCore ? 'dart.JsSymbol' : 'Symbol';
 
   @override
   JS.Statement visitCompilationUnit(CompilationUnit node) {
     var source = node.element.source;
 
     _constEvaluator = new ConstantEvaluator(source, rules.provider);
@@ skipping 167 matching lines @@
 
     JS.Statement genericDef;
     JS.Expression genericInst;
     if (classElem.typeParameters.isNotEmpty) {
       genericDef = _emitGenericClassDef(classElem, body);
       var dynamicArgs = new List.filled(
           classElem.typeParameters.length, js.call('dart.dynamic'));
 
       var target = genericName;
       if (_needQualifiedName(classElem)) {
-        target = js.call('#.#', [_EXPORTS, genericName]);
+        target = js.call('#.#', [_exportsVar, genericName]);
       }
       genericInst = js.call('#(#)', [target, dynamicArgs]);
     }
 
     // The base class and all mixins must be declared before this class.
     if (_lazyClass(classElem)) {
       // TODO(jmesserly): the lazy class def is a simple solution for now.
       // We may want to consider other options in the future.
 
       if (genericDef != null) {
         return js.statement(
             '{ #; dart.defineLazyClassGeneric(#, #, { get: # }); }', [
           genericDef,
-          _EXPORTS,
+          _exportsVar,
           js.string(name, "'"),
           genericName
         ]);
       }
 
       return js.statement(
           'dart.defineLazyClass(#, { get #() { #; return #; } });', [
-        _EXPORTS,
+        _exportsVar,
         _propertyName(name),
         body,
         name
       ]);
     }
 
     if (isPublic(name)) _exports.add(name);
 
     if (genericDef != null) {
       body = js.statement('{ #; let # = #; }', [genericDef, name, genericInst]);
@@ skipping 203 matching lines @@
         var fieldName = field.name.name;
         if (field.isConst || _isFieldInitConstant(field)) {
           var init = _visit(field.initializer);
           if (init == null) init = new JS.LiteralNull();
           body.add(js.statement('#.# = #;', [name, fieldName, init]));
         } else {
           lazyStatics.add(field);
         }
       }
     }
-    var lazy = _emitLazyFields(name, lazyStatics);
+    var lazy = _emitLazyFields(new JS.Identifier(name), lazyStatics);
     if (lazy != null) body.add(lazy);
     return _statement(body);
   }
 
   /// Generates the implicit default constructor for class C of the form
   /// `C() : super() {}`.
   JS.Method _emitImplicitConstructor(
       ClassDeclaration node, String name, List<FieldDeclaration> fields) {
     // If we don't have a method body, skip this.
     if (fields.isEmpty) return null;
@@ skipping 219 matching lines @@
     if (parameters == null || !_hasArgumentInitializers(parameters)) {
       return null;
     }
 
     var body = [];
     for (var param in parameters.parameters) {
       // TODO(justinfagnani): rename identifier if necessary
       var name = param.identifier.name;
 
       if (param.kind == ParameterKind.NAMED) {
-        body.add(js.statement('let # = opt\$ && # in opt\$ ? opt\$.# : #;', [
+        body.add(js.statement('let # = # && # in # ? #.# : #;', [
           name,
+          _namedArgTemp,
           js.string(name, "'"),
+          _namedArgTemp,
+          _namedArgTemp,
           name,
           _defaultParamValue(param),
         ]));
       } else if (param.kind == ParameterKind.POSITIONAL) {
         body.add(js.statement('if (# === void 0) # = #;', [
           name,
           name,
           _defaultParamValue(param)
         ]));
       }
@@ skipping 110 matching lines @@
 
     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);
+    } else if (e is ParameterElement && e.isInitializingFormal && e.isPrivate) {
+      /// Rename private names so they don't shadow the private field symbol.
+      /// The renamer would handle this, but it would prefer to rename the
+      /// temporary used for the private symbol. Instead rename the parameter.
+      return new JSTemporary('${name.substring(1)}');
+    } else if (_isTemporary(e)) {
+      return new JSTemporary(e.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');
@@ skipping 206 matching lines @@
     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>[];
     for (FormalParameter param in node.parameters) {
       if (param.kind == ParameterKind.NAMED) {
-        result.add(new JS.Identifier(r'opt$'));
+        result.add(_namedArgTemp);
         break;
       }
       result.add(_visit(param));
     }
     return result;
   }
 
   @override
   JS.Statement visitExpressionStatement(ExpressionStatement node) =>
       _expressionStatement(_visit(node.expression));
@@ skipping 82 matching lines @@
   }
 
   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();
   }
 
   void _flushLazyFields(List<JS.Statement> body) {
-    var code = _emitLazyFields(_EXPORTS, _lazyFields);
+    var code = _emitLazyFields(_exportsVar, _lazyFields);
     if (code != null) body.add(code);
     _lazyFields.clear();
   }
 
   JS.Statement _emitLazyFields(
-      String objExpr, List<VariableDeclaration> fields) {
+      JS.Expression objExpr, List<VariableDeclaration> fields) {
     if (fields.isEmpty) return null;
 
     var methods = [];
     for (var node in fields) {
       var name = node.name.name;
       methods.add(new JS.Method(_propertyName(name),
           js.call('function() { return #; }', _visit(node.initializer)),
           isGetter: true));
 
       // TODO(jmesserly): use a dummy setter to indicate writable.
       if (!node.isFinal) {
         methods.add(new JS.Method(
             _propertyName(name), js.call('function(_) {}'), isSetter: true));
       }
     }
 
     return js.statement(
         'dart.defineLazyProperties(#, { # });', [objExpr, methods]);
   }
 
   void _flushLibraryProperties(List<JS.Statement> body) {
     if (_properties.isEmpty) return;
-    body.add(js.statement('dart.copyProperties($_EXPORTS, { # });',
-        [_properties.map(_emitTopLevelProperty)]));
+    body.add(js.statement('dart.copyProperties(#, { # });', [
+      _exportsVar,
+      _properties.map(_emitTopLevelProperty)
+    ]));
     _properties.clear();
   }
 
   @override
   JS.Statement visitVariableDeclarationStatement(
           VariableDeclarationStatement node) =>
       _expressionStatement(_visit(node.variables));
 
   @override
   visitConstructorName(ConstructorName node) {
@@ skipping 150 matching lines @@
         // Generic static-dispatch, user-defined operator code path.
         return js.call('#.#(#)', [_visit(left), opString, _visit(right)]);
       }
     }
   }
 
   bool _isNull(Expression expr) => expr is NullLiteral;
 
   // TODO(jmesserly, vsm): Refactor this logic.
   SimpleIdentifier _createTemporary(String name, DartType type) {
+    // We use an invalid source location to signal that this is a temporary.
+    // See [_isTemporary].
+    // TODO(jmesserly): alternatives are
+    // * (ab)use Element.isSynthetic, which isn't currently used for
+    //   LocalVariableElementImpl, so we could repurpose to mean "temp".
+    // * add a new property to LocalVariableElementImpl.
+    // * create a new subtype of LocalVariableElementImpl to mark a temp.
     var id =
-        new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, 0));
+        new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, -1));
     id.staticElement = new LocalVariableElementImpl.forNode(id);
     id.staticType = type;
     return id;
   }
 
+  bool _isTemporary(Element node) => node.nameOffset == -1;
+
   JS.Expression _emitPostfixIncrement(Expression expr, Token op) {
     var type = rules.getStaticType(expr);
     assert(type != null);
-    var tmp = _createTemporary('\$tmp', type);
+    var tmp = _createTemporary('x', type);
 
     // Increment and write
     var one = AstBuilder.integerLiteral(1);
     one.staticType = rules.provider.intType;
     var increment = AstBuilder.binaryExpression(tmp, op.lexeme[0], one);
     increment.staticType = type;
     var write = _emitAssignment(expr, increment);
 
     var bindThis = _maybeBindThis(expr);
     return js.call("((#) => (#, #))$bindThis(#)", [
@@ skipping 91 matching lines @@
         //    (sb.write(1), sb.write(2), sb)
         var sections = _visitListToBinary(node.cascadeSections, ',');
         result = new JS.Binary(',', sections, _visit(_cascadeTarget));
       }
     } else {
       // In the general case we need to capture the target expression into
       // a temporary. This uses a lambda to get a temporary scope, and it also
       // remains valid in an expression context.
       // TODO(jmesserly): need a better way to handle temps.
       // TODO(jmesserly): special case for parent is ExpressionStatement?
-      _cascadeTarget =
-          new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, '_', 0));
-      _cascadeTarget.staticElement =
-          new LocalVariableElementImpl.forNode(_cascadeTarget);
-      _cascadeTarget.staticType = node.target.staticType;
+      _cascadeTarget = _createTemporary('_', node.target.staticType);
 
       var body = _visitList(node.cascadeSections);
       if (node.parent is! ExpressionStatement) {
-        body.add(js.statement('return #;', _cascadeTarget.name));
+        body.add(js.statement('return #;', _visit(_cascadeTarget)));
       }
 
       var bindThis = _maybeBindThis(node.cascadeSections);
       result = js.call('((#) => { # })$bindThis(#)', [
-        _cascadeTarget.name,
+        _visit(_cascadeTarget),
         body,
         _visit(node.target)
       ]);
     }
 
     _cascadeTarget = savedCascadeTemp;
     return result;
   }
 
   /// True is the expression can be evaluated multiple times without causing
@@ skipping 16 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.Identifier(node.identifier.name);
-
-  @override
-  visitFieldFormalParameter(FieldFormalParameter node) =>
-      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;
+      visitSimpleIdentifier(node.identifier);
 
   @override
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
 
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.prefix.staticElement is PrefixElement) {
@@ skipping 52 matching lines @@
     if (node.parent is ExpressionStatement) {
       return js.statement('throw #;', expr);
     } else {
       return js.call('dart.throw_(#)', expr);
     }
   }
 
   @override
   visitRethrowExpression(RethrowExpression node) {
     if (node.parent is ExpressionStatement) {
-      return js.statement('throw #;', _catchParameter);
+      return js.statement('throw #;', _visit(_catchParameter));
     } else {
-      return js.call('dart.throw_(#)', _catchParameter);
+      return js.call('dart.throw_(#)', _visit(_catchParameter));
     }
   }
 
   @override
   JS.If visitIfStatement(IfStatement node) {
     return new JS.If(_visit(node.condition), _visit(node.thenStatement),
         _visitOrEmpty(node.elseStatement));
   }
 
   @override
@@ skipping 40 matching lines @@
     return new JS.Try(_visit(node.body), _visitCatch(node.catchClauses),
         _visit(node.finallyBlock));
   }
 
   _visitCatch(NodeList<CatchClause> clauses) {
     if (clauses == null || clauses.isEmpty) return null;
 
     // TODO(jmesserly): need a better way to get a temporary variable.
     // This could incorrectly shadow a user's name.
     var savedCatch = _catchParameter;
-    _catchParameter = '\$e';
 
     if (clauses.length == 1) {
       // Special case for a single catch.
-      var clause = clauses.single;
-      if (clause.exceptionParameter != null) {
-        _catchParameter = clause.exceptionParameter.name;
-      }
+      _catchParameter = clauses.single.exceptionParameter;
+    } else {
+      _catchParameter = _createTemporary('e', rules.provider.dynamicType);
     }
 
-    var catchVarDecl = new JS.Identifier(_catchParameter);
-    var catchBody = new JS.Block(_visitList(clauses));
+    JS.Statement catchBody = null;
+    for (var clause in clauses.reversed) {
+      catchBody = _catchClauseGuard(clause, catchBody);
+    }
+
+    var catchVarDecl = _visit(_catchParameter);
     _catchParameter = savedCatch;
+    return new JS.Catch(catchVarDecl, new JS.Block([catchBody]));
+  }
 
-    return new JS.Catch(catchVarDecl, catchBody);
+  JS.Statement _catchClauseGuard(CatchClause clause, JS.Statement otherwise) {
+    var then = visitCatchClause(clause);
+
+    // Discard following clauses, if any, as they are unreachable.
+    if (clause.exceptionType == null) return then;
+
+    return new JS.If(js.call('dart.is(#, #)', [
+      _visit(_catchParameter),
+      _emitTypeName(clause.exceptionType.type),
+    ]), then, otherwise);
   }
 
   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);
   }
 
+  /// Visits the catch clause body. This skips the exception type guard, if any.
+  /// That is handled in [_visitCatch].
   @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.Identifier(name.name);
-        decl.sourceInformation = name;
-        body.add(js.statement('let # = #;', [decl, _catchParameter]));
-        _catchParameter = name.name;
+      if (name != null && name != _catchParameter) {
+        body.add(js.statement(
+            'let # = #;', [_visit(name), _visit(_catchParameter)]));
+        _catchParameter = name;
       }
       if (node.stackTraceParameter != null) {
         var stackVar = node.stackTraceParameter.name;
         body.add(js.statement(
             'let # = dart.stackTrace(#);', [stackVar, _visit(name)]));
       }
     }
 
     body.add(_visit(node.body));
     _catchParameter = savedCatch;
-
-    if (node.exceptionType != null) {
-      return js.statement('if (dart.is(#, #)) #;', [
-        _catchParameter,
-        _emitTypeName(node.exceptionType.type),
-        _statement(body)
-      ]);
-    }
-
     return _statement(body);
   }
 
   @override
   JS.Case visitSwitchCase(SwitchCase node) {
     var expr = _visit(node.expression);
     var body = _visitList(node.statements);
     if (node.labels.isNotEmpty) {
       body.insert(0, js.comment('Unimplemented case labels: ${node.labels}'));
     }
@@ skipping 213 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.Identifier(name);
+      return new JSTemporary(name);
     }
     if (name == '[]') {
       name = 'get';
     } else if (name == '[]=') {
       name = 'set';
     } else if (unary && name == '-') {
       name = 'unary-';
     }
     return _propertyName(name);
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
   /// Choose a canonical name from the library element.
   /// This never uses the library's name (the identifier in the `library`
   /// declaration) as it doesn't have any meaningful rules enforced.
-  String _libraryName(LibraryElement library) {
-    if (library == libraryInfo.library) return _EXPORTS;
-    return jsLibraryName(library);
+  JS.Identifier _libraryName(LibraryElement library) {
+    if (library == libraryInfo.library) return _exportsVar;
+    return new JS.Identifier(jsLibraryName(library));
   }
 
   String _maybeBindThis(node) {
     if (currentClass == null) return '';
     var visitor = _BindThisVisitor._instance;
     visitor._bindThis = false;
     node.accept(visitor);
     return visitor._bindThis ? '.bind(this)' : '';
   }
 
-  /// The name for the library's exports inside itself.
-  /// This much be a constant because we interpolate it into template strings,
-  /// and otherwise it would break caching for them.
-  /// `exports` was chosen as the most similar to ES module patterns.
-  static const String _EXPORTS = 'exports';
-
   static bool _needsImplicitThis(Element e) =>
       e is PropertyAccessorElement && !e.variable.isStatic ||
           e is ClassMemberElement && !e.isStatic && e is! ConstructorElement;
 }
 
 /// Returns true if the local variable is potentially mutated within [context].
 /// This accounts for closures that may have been created outside of [context].
 bool _isPotentiallyMutated(VariableElementImpl e, [AstNode context]) {
   if (e.isPotentiallyMutatedInClosure) {
     // TODO(jmesserly): this returns true incorrectly in some cases, because
@@ skipping 87 matching lines @@
       return computeHash(text);
     } else {
       var text = jsNodeToString(jsTree);
       new File(outputPath).writeAsStringSync(text);
       return computeHash(text);
     }
   }
 }
 
 void _writeNode(JS.JavaScriptPrintingContext context, JS.Node node) {
-  var opts = new JS.JavaScriptPrintingOptions(avoidKeywordsInIdentifiers: true);
-  node.accept(new JS.Printer(opts, context));
+  var opts = new JS.JavaScriptPrintingOptions(allowKeywordsInProperties: true);
+  node.accept(new JS.Printer(opts, context, localNamer: new JSNamer(node)));
 }
 
 /// This is a debugging helper to print a JS node.
 String jsNodeToString(JS.Node node) {
   var context = new JS.SimpleJavaScriptPrintingContext();
   _writeNode(context, node);
   return context.getText();
 }
 
 /// Choose a canonical name from the library element.
@@ skipping 76 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;
   }
 }