fix for static methods and names banned in strict mode

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 538 matching lines @@
   JS.Statement _finishClassMembers(String name, JS.ClassExpression cls,
       List<ConstructorDeclaration> ctors, List<FieldDeclaration> staticFields) {
     var body = <JS.Statement>[];
     body.add(new JS.ClassDeclaration(cls));
 
     // Named constructors
     for (ConstructorDeclaration member in ctors) {
       if (member.name != null) {
         body.add(js.statement('dart.defineNamedConstructor(#, #);', [
           name,
-          js.string(member.name.name, "'")
+          _jsMemberName(member.name.name, isStatic: true)
         ]));
       }
     }
 
     // Static fields
     var lazyStatics = <VariableDeclaration>[];
     for (FieldDeclaration member in staticFields) {
       for (VariableDeclaration field in member.fields.variables) {
         var fieldName = field.name.name;
         if (field.isConst || _isFieldInitConstant(field)) {
@@ skipping 275 matching lines @@
 
   @override
   JS.Method visitMethodDeclaration(MethodDeclaration node) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
-    return new JS.Method(
-        _jsMemberName(node.name.name), new JS.Fun(params, _visit(node.body)),
+    return new JS.Method(_jsMemberName(node.name.name, isStatic: node.isStatic),
+        new JS.Fun(params, _visit(node.body)),
         isGetter: node.isGetter,
         isSetter: node.isSetter,
         isStatic: node.isStatic);
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
@@ skipping 68 matching lines @@
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var e = node.staticElement;
     if (e == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     var name = node.name;
     var variable = e is PropertyAccessorElement ? e.variable : e;
 
+    // library member
     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)) {
+    }
+
+    // instance member
+    if (currentClass != null && _needsImplicitThis(e)) {
       return js.call('this.#', _jsMemberName(name));
-    } else if (variable is ConstFieldElementImpl) {
+    }
+
+    // static member
+    if (e is ExecutableElement &&
+        e.isStatic &&
+        variable.enclosingElement is ClassElement) {
       var className = (variable.enclosingElement as ClassElement).name;
-      return js.call('#.#', [className, name]);
-    } else if (e is ParameterElement && e.isInitializingFormal && e.isPrivate) {
+      return js.call('#.#', [className, _jsMemberName(name, isStatic: true)]);
+    }
+
+    // initializing formal parameter, e.g. `Point(this.x)`
+    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);
     }
+
+    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 715 matching lines @@
   @override
   visitPropertyAccess(PropertyAccess node) =>
       _visitGet(_getTarget(node), node.propertyName);
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   _visitGet(Expression target, SimpleIdentifier name) {
     if (rules.isDynamicTarget(target)) {
       return js.call(
           'dart.dload(#, #)', [_visit(target), js.string(name.name, "'")]);
     } else {
-      return js.call('#.#', [_visit(target), _jsMemberName(name.name)]);
+      var e = name.staticElement;
+      return js.call('#.#', [
+        _visit(target),
+        _jsMemberName(name.name, isStatic: e is ExecutableElement && e.isStatic)
+      ]);
     }
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     var target = _getTarget(node);
     var code;
     if (rules.isDynamicTarget(target)) {
       code = 'dart.dindex(#, #)';
     } else {
@@ skipping 379 matching lines @@
   ///
   /// This follows the same pattern as EcmaScript 6 Map:
   /// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map>
   ///
   /// 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}) {
+  JS.Expression _jsMemberName(String name,
+      {bool unary: false, bool isStatic: false}) {
     if (name.startsWith('_')) {
       if (_privateNames.add(name)) _pendingPrivateNames.add(name);
       return new JSTemporary(name);
     }
     if (name == '[]') {
       name = 'get';
     } else if (name == '[]=') {
       name = 'set';
     } else if (unary && name == '-') {
       name = 'unary-';
+    } else if (isStatic && invalidJSStaticMethodName(name)) {
+      // Choose an string name. Use an invalid identifier so it won't conflict
+      // with any valid member names.
+      name = '::$name';

[Jacob, 2015/03/27 21:18:25]

FIXME: we should pick something more sane than ::$name so that JS interop is
reasonable for these cases.
I'd suggest at least changing to 
'${name}::' so that JS console autocomplete shows the renamed name.

     }
     return _propertyName(name);
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
@@ skipping 62 matching lines @@
     if (parent is Label) return;
 
     if (node.inSetterContext() && node.staticElement == _variable) {
       _potentiallyMutated = true;
     }
   }
 }
 
 /// This is a workaround for V8 arrow function bindings being not yet
 /// implemented. See issue #43
+// TODO(jmesserly): cleaner to handle this workaround on the JS side.
 class _BindThisVisitor extends RecursiveAstVisitor {
   static _BindThisVisitor _instance = new _BindThisVisitor();
   bool _bindThis = false;
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     if (JSCodegenVisitor._needsImplicitThis(node.staticElement)) {
       _bindThis = true;
     }
   }
@@ skipping 129 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;
   }
 }