Avoid generating VariableUse nodes with non-identifier names

sdk/lib/_internal/compiler/implementation/js_backend/constant_emitter.dart

 // Copyright (c) 2012, 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.
 
 part of js_backend;
 
 class ConstantEmitter  {
   ConstantReferenceEmitter _referenceEmitter;
   ConstantInitializerEmitter _initializerEmitter;
 
@@ skipping 44 matching lines @@
 
   jsAst.Expression generateInInitializationContext(Constant constant) {
     return _visit(constant);
   }
 
   jsAst.Expression _visit(Constant constant) {
     return constant.accept(this);
   }
 
   jsAst.Expression visitFunction(FunctionConstant constant) {
-    return new jsAst.VariableUse(
-        namer.isolateStaticClosureAccess(constant.element));
+    return namer.isolateStaticClosureAccess(constant.element);
   }
 
   jsAst.Expression visitNull(NullConstant constant) {
     return new jsAst.LiteralNull();
   }
 
   jsAst.Expression visitInt(IntConstant constant) {
     return new jsAst.LiteralNumber('${constant.value}');
   }
 
@@ skipping 134 matching lines @@
 
   jsAst.Expression visitList(ListConstant constant) {
     jsAst.Expression value = new jsAst.Call(
         new jsAst.PropertyAccess.field(
             new jsAst.VariableUse(namer.isolateName),
             'makeConstantList'),
         [new jsAst.ArrayInitializer.from(_array(constant.entries))]);
     return maybeAddTypeArguments(constant.type, value);
   }
 
-  String getJsConstructor(ClassElement element) {
-    return namer.isolateAccess(element);
+  jsAst.Expression getJsConstructor(ClassElement element) {
+    return namer.elementAccess(element);
   }
 
   jsAst.Expression visitMap(MapConstant constant) {
     jsAst.Expression jsMap() {
       List<jsAst.Property> properties = <jsAst.Property>[];
       for (int i = 0; i < constant.keys.entries.length; i++) {
         StringConstant key = constant.keys.entries[i];
         if (key.value == MapConstant.PROTO_PROPERTY) continue;
 
         // Keys in literal maps must be emitted in place.
@@ skipping 51 matching lines @@
     if ((className == MapConstant.DART_STRING_CLASS &&
          emittedArgumentCount != 3) ||
         (className == MapConstant.DART_PROTO_CLASS &&
          emittedArgumentCount != 4) ||
         (className == MapConstant.DART_GENERAL_CLASS &&
          emittedArgumentCount != 1)) {
       compiler.internalError(classElement,
           "Compiler and ${className} disagree on number of fields.");
     }
 
-    jsAst.Expression value = new jsAst.New(
-        new jsAst.VariableUse(getJsConstructor(classElement)),
-        arguments);
+    jsAst.Expression value =
+        new jsAst.New(getJsConstructor(classElement), arguments);
     return maybeAddTypeArguments(constant.type, value);
   }
 
   JavaScriptBackend get backend => compiler.backend;
 
   jsAst.PropertyAccess getHelperProperty(Element helper) {
     return backend.namer.elementAccess(helper);
   }
 
   jsAst.Expression visitType(TypeConstant constant) {
     DartType type = constant.representedType;
     String name = namer.getRuntimeTypeName(type.element);
     jsAst.Expression typeName = new jsAst.LiteralString("'$name'");
     return new jsAst.Call(getHelperProperty(backend.getCreateRuntimeType()),
                           [typeName]);
   }
 
   jsAst.Expression visitInterceptor(InterceptorConstant constant) {
     return new jsAst.PropertyAccess.field(
-        new jsAst.VariableUse(
-            getJsConstructor(constant.dispatchedType.element)),
+        getJsConstructor(constant.dispatchedType.element),
         'prototype');
   }
 
   jsAst.Expression visitDummy(DummyConstant constant) {
     return _reference(constant);
   }
 
   jsAst.Expression visitConstructed(ConstructedConstant constant) {
     Element element = constant.type.element;
     if (element.isForeign(compiler)
         && element.name == 'JS_CONST') {
       StringConstant str = constant.fields[0];
       String value = str.value.slowToString();
       return new jsAst.LiteralExpression(stripComments(value));
     }
     jsAst.New instantiation = new jsAst.New(
-        new jsAst.VariableUse(getJsConstructor(constant.type.element)),
+        getJsConstructor(constant.type.element),
         _array(constant.fields));
     return maybeAddTypeArguments(constant.type, instantiation);
   }
 
   String stripComments(String rawJavaScript) {
     return rawJavaScript.replaceAll(COMMENT_RE, '');
   }
 
   List<jsAst.Expression> _array(List<Constant> values) {
     List<jsAst.Expression> valueList = <jsAst.Expression>[];
@@ skipping 15 matching lines @@
           .map((DartType type) =>
               rti.getTypeRepresentationWithHashes(type, (_){}));
       jsAst.Expression argumentList =
           new jsAst.LiteralString('[${arguments.join(', ')}]');
       return new jsAst.Call(getHelperProperty(backend.getSetRuntimeTypeInfo()),
                             [value, argumentList]);
     }
     return value;
   }
 }