I18N constant maps are now guaranteed to iterate in declaration order. This allows a better degree of user control, and fixes inconsistencies between hosted and web mode. Review by: jat (desk) git-svn-id: https://google-web-toolkit.googlecode.com/svn/releases/1.6@4608 8db76d5a-ed1c-0410-87a9-c151d255dfc7

diff --git a/user/src/com/google/gwt/i18n/client/Constants.java b/user/src/com/google/gwt/i18n/client/Constants.java
index c5be987..8417853 100644
--- a/user/src/com/google/gwt/i18n/client/Constants.java
+++ b/user/src/com/google/gwt/i18n/client/Constants.java

@@ -64,7 +64,7 @@
  * 
  * {@example com.google.gwt.examples.i18n.NumberFormatConstantsAnnot}
  * </p>
- *
+ * 
  * <p>
  * It is also possible to change the property name bound to a constant accessor
  * using the {@code @Key} annotation. For example,
@@ -152,7 +152,8 @@
  * the constant accessor <code>someMap()</code> would return a
  * <code>Map</code> that maps <code>"a"</code> onto <code>"X"</code>,
  * <code>"b"</code> onto <code>"Y"</code>, and <code>"c"</code> onto
- * <code>"Z"</code>.
+ * <code>"Z"</code>. Iterating through this <code>Map</code> will return
+ * the keys or entries in declaration order.
  * </p>
  * 
  * <p>The benefit of using annotations, aside from not having to switch to

diff --git a/user/src/com/google/gwt/i18n/client/impl/ConstantMap.java b/user/src/com/google/gwt/i18n/client/impl/ConstantMap.java
index 0ecec17..f683e97 100644
--- a/user/src/com/google/gwt/i18n/client/impl/ConstantMap.java
+++ b/user/src/com/google/gwt/i18n/client/impl/ConstantMap.java

@@ -20,10 +20,9 @@
 import java.util.AbstractMap;
 import java.util.AbstractSet;
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.NoSuchElementException;
 import java.util.Set;
 
 /**
@@ -33,10 +32,62 @@
  */
 public class ConstantMap extends AbstractMap<String, String> {
 
-  /**
-   * A cache of a synthesized entry set.
-   */
-  private Set<Map.Entry<String, String>> entries;
+  private static final class EntryImpl implements Entry<String, String> {
+    private final String key;
+    private final String value;
+
+    private EntryImpl(String key, String value) {
+      assert (key != null);
+      assert (value != null);
+      this.key = key;
+      this.value = value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (o instanceof Map.Entry) {
+        Map.Entry<?, ?> other = (Map.Entry<?, ?>) o;
+        // Key and value known to be non-null.
+        if (key.equals(other.getKey()) && value.equals(other.getValue())) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    public String getKey() {
+      return key;
+    }
+
+    public String getValue() {
+      return value;
+    }
+
+    /**
+     * Calculate the hash code using Sun's specified algorithm.
+     */
+    @Override
+    public int hashCode() {
+      int keyHash = 0;
+      int valueHash = 0;
+      if (getKey() != null) {
+        keyHash = getKey().hashCode();
+      }
+      if (getValue() != null) {
+        valueHash = getValue().hashCode();
+      }
+      return keyHash ^ valueHash;
+    }
+
+    public String setValue(String value) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public String toString() {
+      return key + "=" + value;
+    }
+  }
 
   /**
    * The original set of keys.
@@ -56,6 +107,8 @@
     init();
 
     for (int i = 0; i < keys.length; ++i) {
+      assert keys[i] != null;
+      assert values[i] != null;
       putImpl(keys[i], values[i]);
     }
   }
@@ -67,14 +120,48 @@
 
   @Override
   public Set<Map.Entry<String, String>> entrySet() {
-    if (entries == null) {
-      Map<String, String> copy = new HashMap<String, String>();
-      for (String key : keys) {
-        copy.put(key, get(key));
+    return new AbstractSet<Entry<String, String>>() {
+      @Override
+      public boolean contains(Object o) {
+        if (!(o instanceof Entry)) {
+          return false;
+        }
+        Entry<?, ?> other = (Entry<?, ?>) o;
+        String value = get(other.getKey());
+        if (value != null && value.equals(other.getValue())) {
+          return true;
+        }
+        return false;
       }
-      entries = Collections.unmodifiableMap(copy).entrySet();
-    }
-    return entries;
+
+      @Override
+      public Iterator<Map.Entry<String, String>> iterator() {
+        return new Iterator<Entry<String, String>>() {
+          private int next = 0;
+
+          public boolean hasNext() {
+            return next < ConstantMap.this.size();
+          }
+
+          public Entry<String, String> next() {
+            if (!hasNext()) {
+              throw new NoSuchElementException();
+            }
+            String key = keys[next++];
+            return new EntryImpl(key, get(key));
+          }
+
+          public void remove() {
+            throw new UnsupportedOperationException();
+          }
+        };
+      }
+
+      @Override
+      public int size() {
+        return ConstantMap.this.size();
+      }
+    };
   }
 
   @Override

diff --git a/user/src/com/google/gwt/i18n/rebind/ConstantsMapMethodCreator.java b/user/src/com/google/gwt/i18n/rebind/ConstantsMapMethodCreator.java
index a192966..ee6fa28 100644
--- a/user/src/com/google/gwt/i18n/rebind/ConstantsMapMethodCreator.java
+++ b/user/src/com/google/gwt/i18n/rebind/ConstantsMapMethodCreator.java

@@ -22,8 +22,8 @@
 import com.google.gwt.i18n.rebind.AbstractResource.ResourceList;
 import com.google.gwt.user.rebind.AbstractGeneratorClassCreator;
 
-import java.util.SortedMap;
-import java.util.TreeMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
 
 /**
  * Creator for methods of the form Map getX() .
@@ -81,7 +81,8 @@
 
     String[] keys = ConstantsStringArrayMethodCreator.split(keyString);
     ResourceList resources = getResources();
-    SortedMap<String, String> map = new TreeMap<String, String>();
+    // Use a LinkedHashMap to preserve declaration order (but remove dups).
+    Map<String, String> map = new LinkedHashMap<String, String>();
     for (String key : keys) {
       if (key.length() == 0) {
         continue;