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

lib/src/codegen/js_names.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_names;
 
 import 'dart:collection';
 import 'package:dev_compiler/src/js/js_ast.dart';
 
 /// Unique instance for temporary variables. Will be renamed consistently
 /// across the entire file. Different instances will be named differently
 /// even if they have the same name, this makes it safe to use in code
 /// generation without needing global knowledge. See [JSNamer].
 ///
 // TODO(jmesserly): move into js_ast? add a boolean to Identifier?
-class JSTemporary extends Identifier {
-  JSTemporary(String name) : super(name);
+class TemporaryId extends Identifier {
+  TemporaryId(String name) : super(name);
 }
 
 /// This class has two purposes:
 ///
 /// * rename JS identifiers to avoid keywords.
 /// * rename temporary variables to avoid colliding with user-specified names,
 ///   or other temporaries
 ///
 /// Each instance of [JSTemporary] is treated as a unique variable, with its
 /// `name` field simply the suggestion of what name to use. By contrast
 /// [Identifiers] are never renamed unless they are an invalid identifier, like
 /// `function` or `instanceof`, and their `name` field controls whether they
 /// refer to the same variable.
-class JSNamer extends LocalNamer {
+class TemporaryNamer extends LocalNamer {
   final Map<Object, String> renames;
 
-  JSNamer(Node node) : renames = new _RenameVisitor.build(node).renames;
+  TemporaryNamer(Node node) : renames = new _RenameVisitor.build(node).renames;
 
   String getName(Identifier node) {
     var rename = renames[identifierKey(node)];
     if (rename != null) return rename;
 
     assert(!needsRename(node));
     return node.name;
   }
 
   void enterScope(FunctionExpression node) {}
@@ skipping 100 matching lines @@
       var name = _findName(id, allNames);
       renames[id] = name;
 
       for (var s in scopes) s.used.add(name);
     });
   }
 
   static String _findName(Object id, Set<String> usedNames) {
     String name;
     bool valid;
-    if (id is JSTemporary) {
+    if (id is TemporaryId) {
       name = id.name;
-      valid = !invalidJSVariableName(name);
+      valid = !invalidVariableName(name);
     } else {
       name = id;
       valid = false;
     }
 
     // Try to use the temp's name, otherwise rename.
     String candidate;
     if (valid && !usedNames.contains(name)) {
       candidate = name;
     } else {
       // This assumes that collisions are rare, hence linear search.
       // If collisions become common we need a better search.
       // TODO(jmesserly): what's the most readable scheme here? Maybe 1-letter
       // names in some cases?
       candidate = name == 'function' ? 'func' : '${name}\$';
       for (int i = 0; usedNames.contains(candidate); i++) {
         candidate = '${name}\$$i';
       }
     }
     return candidate;
   }
 }
 
 bool needsRename(Identifier node) =>
-    node is JSTemporary || node.allowRename && invalidJSVariableName(node.name);
+    node is TemporaryId || node.allowRename && invalidVariableName(node.name);
 
 Object /*String|JSTemporary*/ identifierKey(Identifier node) =>
-    node is JSTemporary ? node : node.name;
+    node is TemporaryId ? node : node.name;
 
 /// Returns true for invalid JS variable names, such as keywords.
 /// Also handles invalid variable names in strict mode, like "arguments".
-bool invalidJSVariableName(String keyword, {bool strictMode: true}) {
+bool invalidVariableName(String keyword, {bool strictMode: true}) {
   switch (keyword) {
     case "break":
     case "case":
     case "catch":
     case "class":
     case "const":
     case "continue":
     case "debugger":
     case "default":
     case "delete":
@@ skipping 26 matching lines @@
       return true;
     case "arguments":
     case "eval":
       return strictMode;
   }
   return false;
 }
 
 /// Returns true for invalid static method names in strict mode.
 /// In particular, "caller" "callee" and "arguments" cannot be used.
-bool invalidJSStaticMethodName(String name) {
+bool invalidStaticMethodName(String name) {
   switch (name) {
     case "arguments":
     case "caller":
     case "callee":
       return true;
   }
   return false;
 }