fixes private named constructors

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 597 matching lines @@
         node.name == null) {
       // Implements Dart constructor behavior. Because of V8 `super`
       // [constructor restrictions]
       // (https://code.google.com/p/v8/issues/detail?id=3330#c65)
       // we cannot currently emit actual ES6 constructors with super calls.
       // Instead we use the same trick as named constructors, and do them as
       // instance methods that perform initialization.
       // TODO(jmesserly): we'll need to rethink this once the ES6 spec and V8
       // settles. See <https://github.com/dart-lang/dev_compiler/issues/51>.
       // Performance of this pattern is likely to be bad.
-      name = 'constructor';
+      name = js.string('constructor', "'");
       // Mark the parameter as no-rename.
       var args = new JS.Identifier('arguments', allowRename: false);
       body = js.statement('''{
         // Get the class name for this instance.
         var name = this.constructor.name;
         // Call the default constructor.
         var init = this[name];
         var result = void 0;
         if (init) result = init.apply(this, #);
         return result === void 0 ? this : result;
       }''', args);
     } else {
       body = _emitConstructorBody(node, fields);
     }
 
     // We generate constructors as initializer methods in the class;
     // this allows use of `super` for instance methods/properties.
     // It also avoids V8 restrictions on `super` in default constructors.
-    return new JS.Method(
-        _propertyName(name), new JS.Fun(_visit(node.parameters), body))
+    return new JS.Method(name, new JS.Fun(_visit(node.parameters), body))
       ..sourceInformation = node;
   }
 
-  String _constructorName(String className, SimpleIdentifier name) {
-    if (name == null) return className;
-    return '$className\$${name.name}';
+  JS.Expression _constructorName(String className, SimpleIdentifier name) {
+    if (name == null) return js.string(className, "'");
+    return _jsMemberName(name.name, isStatic: true);
   }
 
   JS.Block _emitConstructorBody(
       ConstructorDeclaration node, List<FieldDeclaration> fields) {
     // Wacky factory redirecting constructors: factory Foo.q(x, y) = Bar.baz;
     if (node.redirectedConstructor != null) {
       return js.statement('{ return new #(#); }', [
         _visit(node.redirectedConstructor),
         _visit(node.parameters)
       ]);
@@ skipping 39 matching lines @@
     return new JS.Block(body)..sourceInformation = node;
   }
 
   @override
   JS.Statement visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     ClassDeclaration classDecl = node.parent.parent;
     var className = classDecl.name.name;
 
     var name = _constructorName(className, node.constructorName);
-    return js.statement(
-        'this.#(#);', [_jsMemberName(name), _visit(node.argumentList)]);
+    return js.statement('this.#(#);', [name, _visit(node.argumentList)]);
   }
 
   JS.Statement _superConstructorCall(ClassDeclaration clazz,
       [SuperConstructorInvocation node]) {
     var superCtorName = node != null ? node.constructorName : null;
 
     var element = clazz.element;
     if (superCtorName == null &&
         (element.type.isObject || element.supertype.isObject)) {
       return null;
@@ skipping 624 matching lines @@
 
   @override
   JS.Statement visitVariableDeclarationStatement(
           VariableDeclarationStatement node) =>
       _expressionStatement(_visit(node.variables));
 
   @override
   visitConstructorName(ConstructorName node) {
     var typeName = _visit(node.type.name);
     if (node.name != null) {
-      return js.call('#.#', [typeName, node.name.name]);
+      return js.call(
+          '#.#', [typeName, _jsMemberName(node.name.name, isStatic: true)]);
     }
     return typeName;
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     return js.call(
         'new #(#)', [_visit(node.constructorName), _visit(node.argumentList)]);
   }
 
@@ skipping 993 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;
   }
 }