small refactor: use JS.* prefix for our other JS extensions

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 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 13 matching lines @@
 import 'package:dev_compiler/src/js/js_ast.dart' show js;
 
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/dependency_graph.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/utils.dart';
 
 import 'code_generator.dart';
 import 'js_field_storage.dart';
-import 'js_names.dart' show JSTemporary, invalidJSStaticMethodName;
-import 'js_metalet.dart';
+import 'js_names.dart' as JS;
+import 'js_metalet.dart' as JS;
 import 'js_printer.dart' show writeJsLibrary;
 import 'side_effect_analysis.dart';
 
 // Various dynamic helpers we call.
 // If renaming these, make sure to check other places like the
 // dart_runtime.js file and comments.
 // TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
 // import and generate calls to, rather than dart_runtime.js
 const DPUT = 'dput';
 const DLOAD = 'dload';
@@ skipping 18 matching lines @@
   SimpleIdentifier _cascadeTarget;
 
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
 
   ConstantEvaluator _constEvaluator;
 
   final _exports = new Set<String>();
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
-  final _privateNames = new HashMap<String, JSTemporary>();
+  final _privateNames = new HashMap<String, JS.TemporaryId>();
   final _extensionMethodNames = new HashSet<String>();
   final _pendingStatements = <JS.Statement>[];
-  final _temps = new HashMap<Element, JSTemporary>();
+  final _temps = new HashMap<Element, JS.TemporaryId>();
 
   /// 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');
+  final _exportsVar = new JS.TemporaryId('exports');
+  final _namedArgTemp = new JS.TemporaryId('opts');
 
   /// Classes we have not emitted yet. Values can be [ClassDeclaration] or
   /// [ClassTypeAlias].
   final _pendingClasses = new HashMap<Element, CompilationUnitMember>();
 
   /// Memoized results of [_lazyClass].
   final _lazyClassMemo = new HashMap<Element, bool>();
 
   /// Memoized results of [_inLibraryCycle].
   final _libraryCycleMemo = new HashMap<LibraryElement, bool>();
@@ skipping 995 matching lines @@
       if (name[0] == '#') {
         return new JS.InterpolatedExpression(name.substring(1));
       } else {
         return _getTemp(element, name);
       }
     }
 
     return new JS.Identifier(name);
   }
 
-  JSTemporary _getTemp(Object key, String name) =>
-      _temps.putIfAbsent(key, () => new JSTemporary(name));
+  JS.TemporaryId _getTemp(Object key, String name) =>
+      _temps.putIfAbsent(key, () => new JS.TemporaryId(name));
 
   JS.ArrayInitializer _emitTypeNames(List<DartType> types) {
     return new JS.ArrayInitializer(types.map(_emitTypeName).toList());
   }
 
   JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types) {
     var properties = <JS.Property>[];
     types.forEach((name, type) {
       var key = new JS.LiteralString(name);
       var value = _emitTypeName(type);
@@ skipping 78 matching lines @@
   @override
   JS.Expression visitAssignmentExpression(AssignmentExpression node) {
     var left = node.leftHandSide;
     var right = node.rightHandSide;
     if (node.operator.type == TokenType.EQ) return _emitSet(left, right);
     return _emitOpAssign(
         left, right, node.operator.lexeme[0], node.staticElement,
         context: node);
   }
 
-  JSMetaLet _emitOpAssign(
+  JS.MetaLet _emitOpAssign(
       Expression left, Expression right, String op, ExecutableElement element,
       {Expression context}) {
     // Desugar `x += y` as `x = x + y`, ensuring that if `x` has subexpressions
     // (for example, x is IndexExpression) we evaluate those once.
     var vars = {};
     var lhs = _bindLeftHandSide(vars, left, context: context);
     var inc = AstBuilder.binaryExpression(lhs, op, right);
     inc.staticElement = element;
     inc.staticType = getStaticType(left);
-    return new JSMetaLet(vars, [_emitSet(lhs, inc)]);
+    return new JS.MetaLet(vars, [_emitSet(lhs, inc)]);
   }
 
   JS.Expression _emitSet(Expression lhs, Expression rhs) {
     if (lhs is IndexExpression) {
       return _emitSend(_getTarget(lhs), '[]=', [lhs.index, rhs]);
     }
 
     Expression target = null;
     SimpleIdentifier id;
     if (lhs is PropertyAccess) {
@@ skipping 550 matching lines @@
   /// We also need to ensure we can return the original value of the expression,
   /// and that it is only evaluated once.
   ///
   /// We desugar this using let*.
   ///
   /// For example, `expr1[expr2]++` can be transformed to this:
   ///
   ///     // psuedocode mix of Scheme and JS:
   ///     (let* (x1=expr1, x2=expr2, t=expr1[expr2]) { x1[x2] = t + 1; t })
   ///
-  /// The [JSMetaLet] nodes automatically simplify themselves if they can.
+  /// The [JS.JS.MetaLet] nodes automatically simplify themselves if they can.
   /// For example, if the result value is not used, then `t` goes away.
   @override
   JS.Expression visitPostfixExpression(PostfixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
       if (_isNonNullableExpression(expr)) {
         return js.call('#$op', _visit(expr));
@@ skipping 10 matching lines @@
     // Desugar `x++` as `(x1 = x0 + 1, x0)` where `x0` is the original value
     // and `x1` is the new value for `x`.
     var x = _bindValue(vars, 'x', left, context: expr);
 
     var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
     var increment = AstBuilder.binaryExpression(x, op.lexeme[0], one)
       ..staticElement = node.staticElement
       ..staticType = getStaticType(expr);
 
     var body = [_emitSet(left, increment), _visit(x)];
-    return new JSMetaLet(vars, body, statelessResult: true);
+    return new JS.MetaLet(vars, body, statelessResult: true);
   }
 
   @override
   JS.Expression visitPrefixExpression(PrefixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
       if (_isNonNullableExpression(expr)) {
         return js.call('$op#', _visit(expr));
       } else if (op.lexeme == '++' || op.lexeme == '--') {
         // We need a null check, so the increment must be expanded out.
         var mathop = op.lexeme[0];
         var vars = {};
         var x = _bindLeftHandSide(vars, expr, context: expr);
         var body = js.call('# = # $mathop 1', [_visit(x), notNull(x)]);
-        return new JSMetaLet(vars, [body]);
+        return new JS.MetaLet(vars, [body]);
       } else {
         return js.call('$op#', notNull(expr));
       }
     }
 
     if (op.lexeme == '++' || op.lexeme == '--') {
       // Increment or decrement requires expansion.
       // Desugar `++x` as `x = x + 1`, ensuring that if `x` has subexpressions
       // (for example, x is IndexExpression) we evaluate those once.
       var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
       return _emitOpAssign(expr, one, op.lexeme[0], node.staticElement,
           context: expr);
     }
 
     return _emitSend(expr, op.lexeme[0], []);
   }
 
   // Cascades can contain [IndexExpression], [MethodInvocation] and
   // [PropertyAccess]. The code generation for those is handled in their
   // respective visit methods.
   @override
   JS.Node visitCascadeExpression(CascadeExpression node) {
     var savedCascadeTemp = _cascadeTarget;
 
     var vars = {};
     _cascadeTarget = _bindValue(vars, '_', node.target, context: node);
     var sections = _visitList(node.cascadeSections);
     sections.add(_visit(_cascadeTarget));
-    var result = new JSMetaLet(vars, sections, statelessResult: true);
+    var result = new JS.MetaLet(vars, sections, statelessResult: true);
     _cascadeTarget = savedCascadeTemp;
     return result;
   }
 
   @override
   visitParenthesizedExpression(ParenthesizedExpression node) =>
       // The printer handles precedence so we don't need to.
       _visit(node.expression);
 
   @override
@@ skipping 483 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 _emitMemberName(String name,
       {DartType type, bool unary: false, bool isStatic: false}) {
     if (name.startsWith('_')) {
       return _privateNames.putIfAbsent(
-          name, () => _initSymbol(new JSTemporary(name)));
+          name, () => _initSymbol(new JS.TemporaryId(name)));
     }
 
     // Check for extension method:
     var extLibrary = _findExtensionLibrary(name, type);
 
     if (name == '[]') {
       name = 'get';
     } else if (name == '[]=') {
       name = 'set';
     } else if (name == '-' && unary) {
       name = 'unary-';
     }
 
-    if (isStatic && invalidJSStaticMethodName(name)) {
+    if (isStatic && JS.invalidStaticMethodName(name)) {
       // Choose an string name. Use an invalid identifier so it won't conflict
       // with any valid member names.
       // TODO(jmesserly): this works around the problem, but I'm pretty sure we
       // don't need it, as static methods seemed to work. The only concrete
       // issue we saw was in the defineNamedConstructor helper function.
       name = '$name*';
     }
 
     if (extLibrary != null) {
       return _extensionMethodName(name, extLibrary);
@@ skipping 123 matching lines @@
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 bool _isJsPeerInterface(DartObjectImpl value) =>
     value.type.name == 'JsPeerInterface';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;