dart2js: Use separate namespace for constants.

pkg/compiler/lib/src/js_backend/namer.dart

 // Copyright (c) 2011, 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;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  *
  * Names are generated through three stages:
@@ skipping 369 matching lines @@
   /// [_disambiguateMember], [_disambiguateInternalMember],
   /// [_disambiguateOperator], and [reservePublicMemberName].
   final Set<String> usedInstanceNames = new Set<String>();
   final Map<String, jsAst.Name> userInstanceMembers =
       new HashMap<String, jsAst.Name>();
   final Map<Element, jsAst.Name> internalInstanceMembers =
       new HashMap<Element, jsAst.Name>();
   final Map<String, jsAst.Name> userInstanceOperators =
       new HashMap<String, jsAst.Name>();
 
+  /// Used to disambiguate names for constants in [constantName].
+  final Set<String> usedConstantNames = new Set<String>();
+
   Set<String> getUsedNames(NamingScope scope) {
     if (scope == NamingScope.global) {
       return usedGlobalNames;
+    } else if (scope == NamingScope.instance){
+      return usedInstanceNames;
     } else {
-      assert(scope == NamingScope.instance);
-      return usedInstanceNames;
+      assert(scope == NamingScope.constant);
+      return usedConstantNames;
     }
   }
 
   final Map<String, int> popularNameCounters = <String, int>{};
 
   final Map<LibraryElement, String> libraryLongNames =
       new HashMap<LibraryElement, String>();
 
   final Map<ConstantValue, jsAst.Name> constantNames =
       new HashMap<ConstantValue, jsAst.Name>();
@@ skipping 12 matching lines @@
   /// names be given to the first item with the given proposed name.
   ///
   /// This is currently used in [MinifyNamer] to assign very short minified
   /// names to things that tend to be used very often.
   final Map<String, String> suggestedGlobalNames = <String, String>{};
   final Map<String, String> suggestedInstanceNames = <String, String>{};
 
   Map<String, String> getSuggestedNames(NamingScope scope) {
     if (scope == NamingScope.global) {
       return suggestedGlobalNames;
+    } else if (scope == NamingScope.instance) {
+      return suggestedInstanceNames;
     } else {
-      assert(scope == NamingScope.instance);
-      return suggestedInstanceNames;
+      assert(scope == NamingScope.constant);
+      return const {};
     }
   }
 
 
   /// Used to store unique keys for library names. Keys are not used as names,
   /// nor are they visible in the output. The only serve as an internal
   /// key into maps.
   final Map<LibraryElement, String> _libraryKeys =
       new HashMap<LibraryElement, String>();
 
@@ skipping 76 matching lines @@
   ///
   /// Unique within the global-member namespace.
   jsAst.Name constantName(ConstantValue constant) {
     // In the current implementation it doesn't make sense to give names to
     // function constants since the function-implementation itself serves as
     // constant and can be accessed directly.
     assert(!constant.isFunction);
     jsAst.Name result = constantNames[constant];
     if (result == null) {
       String longName = constantLongName(constant);
-      result = getFreshName(NamingScope.global, longName);
+      result = getFreshName(NamingScope.constant, longName);
       constantNames[constant] = result;
     }
     return result;
   }
 
   /// Proposed name for [constant].
   String constantLongName(ConstantValue constant) {
     String longName = constantLongNames[constant];
     if (longName == null) {
       longName = new ConstantNamingVisitor(compiler, constantHasher)
@@ skipping 1431 matching lines @@
         sb.write('_');
         visit(parameter);
         first = true;
       }
     }
   }
 }
 
 enum NamingScope {
   global,
-  instance
+  instance,
+  constant
 }