diff --git a/dev/core/src/com/google/gwt/dev/cfg/BindingProperty.java b/dev/core/src/com/google/gwt/dev/cfg/BindingProperty.java
index 039bcc2..36cb777 100644
--- a/dev/core/src/com/google/gwt/dev/cfg/BindingProperty.java
+++ b/dev/core/src/com/google/gwt/dev/cfg/BindingProperty.java
@@ -31,10 +31,10 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
+import java.util.Map.Entry;
 import java.util.regex.Pattern;
 
 /**
@@ -48,15 +48,13 @@
   private static final String EMPTY = "";
 
   private List<SortedSet<String>> collapsedValues = Lists.create();
-  private final Map<Condition, SortedSet<String>> conditionalValues =
-      new LinkedHashMap<Condition, SortedSet<String>>();
+  private final Map<Condition, SortedSet<String>> conditionalValues = new LinkedHashMap<Condition, SortedSet<String>>();
   private final SortedSet<String> definedValues = new TreeSet<String>();
   private PropertyProvider provider;
   private Class<? extends PropertyProviderGenerator> providerGenerator;
   private String fallback;
-  private HashMap<String, LinkedList<LinkedHashSet<String>>> fallbackValueMap;
-  private HashMap<String, LinkedList<String>> fallbackValues =
-      new HashMap<String, LinkedList<String>>();
+  private HashMap<String,LinkedList<LinkedHashSet<String>>> fallbackValueMap;
+  private HashMap<String,LinkedList<String>> fallbackValues = new HashMap<String,LinkedList<String>>();
   private final ConditionAll rootCondition = new ConditionAll();
 
   {
@@ -79,7 +77,8 @@
         // Expanded in normalizeCollapsedValues()
         continue;
       } else if (!definedValues.contains(value)) {
-        throw new IllegalArgumentException("Attempting to collapse unknown value " + value);
+        throw new IllegalArgumentException(
+            "Attempting to collapse unknown value " + value);
       }
     }
 
@@ -100,8 +99,7 @@
   }
 
   /**
-   * Adds fall back value to given property name.
-   * 
+   * Adds fall back value to given property name. 
    * @param value the property value.
    * @param fallbackValue the fall back value for given property value.
    */
@@ -166,15 +164,13 @@
   }
 
   /**
-   * Returns the map of values to fall back values. the list of fall back values
-   * is in decreasing order of preference.
-   * 
+   * Returns the map of values to fall back values. the list of fall
+   * back values is in decreasing order of preference.
    * @return map of property value to fall back values.
    */
-  public Map<String, ? extends List<? extends Set<String>>> getFallbackValuesMap() {
+  public Map<String,? extends List<? extends Set<String>>> getFallbackValuesMap() {
     if (fallbackValueMap == null) {
-      HashMap<String, LinkedList<LinkedHashSet<String>>> valuesMap =
-          new HashMap<String, LinkedList<LinkedHashSet<String>>>();
+      HashMap<String,LinkedList<LinkedHashSet<String>>> valuesMap = new HashMap<String,LinkedList<LinkedHashSet<String>>>();
       // compute closure of fall back values preserving order
       for (Entry<String, LinkedList<String>> e : fallbackValues.entrySet()) {
         String from = e.getKey();
@@ -183,7 +179,8 @@
         LinkedList<String> childList = fallbackValues.get(from);
         LinkedHashSet<String> children = new LinkedHashSet<String>();
         children.addAll(childList);
-        while (children != null && children.size() > 0) {
+        while (children != null && children.size() > 0) 
+        {
           alternates.add(children);
           LinkedHashSet<String> newChildren = new LinkedHashSet<String>();
           for (String child : children) {
@@ -202,7 +199,7 @@
     }
     return fallbackValueMap;
   }
-
+  
   public PropertyProvider getProvider() {
     return provider;
   }
@@ -265,7 +262,7 @@
    * the currently-defined values.
    * 
    * @throws IllegalArgumentException if any of the provided values were not
-   *           provided to {@link #addDefinedValue(Condition,String)}.
+   *     provided to {@link #addDefinedValue(Condition,String)}.
    */
   public void setAllowedValues(Condition condition, String... values) {
     SortedSet<String> temp = new TreeSet<String>(Arrays.asList(values));
@@ -311,29 +308,6 @@
    * Create a minimal number of equivalence sets, expanding any glob patterns.
    */
   void normalizeCollapsedValues() {
-    /*
-     * Properties that depend upon a collapsed property value must be recombined
-     * into an equivalence set.
-     */
-    if (!getRequiredProperties().isEmpty()) {
-      // This defines additional equivalence sets
-      Map<String, SortedSet<String>> requiredPropertyNamesToDependentValues =
-          new HashMap<String, SortedSet<String>>();
-      for (Map.Entry<Condition, SortedSet<String>> entry : getConditionalValues().entrySet()) {
-        for (String requiredPropertyName : entry.getKey().getRequiredProperties()) {
-          SortedSet<String> set = requiredPropertyNamesToDependentValues.get(requiredPropertyName);
-          if (set == null) {
-            set = new TreeSet<String>();
-            requiredPropertyNamesToDependentValues.put(requiredPropertyName, set);
-          }
-          set.addAll(entry.getValue());
-        }
-      }
-      for (SortedSet<String> valuesToCollapse : requiredPropertyNamesToDependentValues.values()) {
-        addCollapsedValues(valuesToCollapse.toArray(new String[valuesToCollapse.size()]));
-      }
-    }
-
     if (collapsedValues.isEmpty()) {
       return;
     }
@@ -394,8 +368,8 @@
     }
 
     // The values of the maps will now contain the minimal number of sets
-    collapsedValues =
-        new ArrayList<SortedSet<String>>(new IdentityHashSet<SortedSet<String>>(map.values()));
+    collapsedValues = new ArrayList<SortedSet<String>>(
+        new IdentityHashSet<SortedSet<String>>(map.values()));
 
     // Sort the list
     Lists.sort(collapsedValues, new Comparator<SortedSet<String>>() {
diff --git a/dev/core/src/com/google/gwt/dev/cfg/PropertyPermutations.java b/dev/core/src/com/google/gwt/dev/cfg/PropertyPermutations.java
index 58a4018..48dfef1 100644
--- a/dev/core/src/com/google/gwt/dev/cfg/PropertyPermutations.java
+++ b/dev/core/src/com/google/gwt/dev/cfg/PropertyPermutations.java
@@ -61,12 +61,12 @@
      * We delete items from this set, but want to retain the original order as
      * much as possible.
      */
-    Set<BindingProperty> bindingProps =
-        new LinkedHashSet<BindingProperty>(properties.getBindingProperties());
+    Set<BindingProperty> bindingProps = new LinkedHashSet<BindingProperty>(
+        properties.getBindingProperties());
 
     // Accumulates the order in which the properties should be evaluated
-    Map<String, BindingProperty> evaluationOrder =
-        new LinkedHashMap<String, BindingProperty>(bindingProps.size());
+    Map<String, BindingProperty> evaluationOrder = new LinkedHashMap<String, BindingProperty>(
+        bindingProps.size());
 
     /*
      * Insert a property after all of the properties that it depends upon have
@@ -87,16 +87,19 @@
       }
 
       if (!changed) {
-        throw new IllegalStateException("Cycle detected within remaining property dependencies "
-            + bindingProps.toString());
+        throw new IllegalStateException(
+            "Cycle detected within remaining property dependencies "
+                + bindingProps.toString());
       }
     }
 
-    return evaluationOrder.values().toArray(new BindingProperty[evaluationOrder.size()]);
+    return evaluationOrder.values().toArray(
+        new BindingProperty[evaluationOrder.size()]);
   }
 
-  private static void permute(BindingProperty[] properties, Set<String> activeLinkerNames,
-      String[] soFar, int whichProp, List<String[]> permutations) {
+  private static void permute(BindingProperty[] properties,
+      Set<String> activeLinkerNames, String[] soFar, int whichProp,
+      List<String[]> permutations) {
     int lastProp = properties.length - 1;
 
     BindingProperty prop = properties[whichProp];
@@ -108,17 +111,18 @@
     } else {
       BindingProperty[] answerable = new BindingProperty[soFar.length];
       System.arraycopy(properties, 0, answerable, 0, soFar.length);
-      PropertyOracle propertyOracle =
-          new StaticPropertyOracle(answerable, soFar, new ConfigurationProperty[0]);
+      PropertyOracle propertyOracle = new StaticPropertyOracle(answerable,
+          soFar, new ConfigurationProperty[0]);
 
       for (Condition cond : prop.getConditionalValues().keySet()) {
         try {
-          if (cond.isTrue(TreeLogger.NULL, new DeferredBindingQuery(propertyOracle,
-              activeLinkerNames))) {
+          if (cond.isTrue(TreeLogger.NULL, new DeferredBindingQuery(
+              propertyOracle, activeLinkerNames))) {
             winner = cond;
           }
         } catch (UnableToCompleteException e) {
-          throw new IllegalStateException("Should never get here for simple properties", e);
+          throw new IllegalStateException(
+              "Should never get here for simple properties", e);
         }
       }
     }
@@ -136,7 +140,8 @@
       nextStep[whichProp] = knownValue;
 
       if (whichProp < lastProp) {
-        permute(properties, activeLinkerNames, nextStep, whichProp + 1, permutations);
+        permute(properties, activeLinkerNames, nextStep, whichProp + 1,
+            permutations);
       } else {
         // Finished this permutation.
         permutations.add(nextStep);
@@ -147,12 +152,14 @@
   private final Properties properties;
   private final List<String[]> values;
 
-  public PropertyPermutations(Properties properties, Set<String> activeLinkerNames) {
+  public PropertyPermutations(Properties properties,
+      Set<String> activeLinkerNames) {
     this.properties = properties;
     this.values = allPermutationsOf(properties, activeLinkerNames);
   }
 
-  public PropertyPermutations(PropertyPermutations allPermutations, int firstPerm, int numPerms) {
+  public PropertyPermutations(PropertyPermutations allPermutations,
+      int firstPerm, int numPerms) {
     this.properties = allPermutations.properties;
     values = allPermutations.values.subList(firstPerm, firstPerm + numPerms);
   }
@@ -160,7 +167,8 @@
   /**
    * Copy constructor that allows the list of property values to be reset.
    */
-  public PropertyPermutations(PropertyPermutations allPermutations, List<String[]> values) {
+  public PropertyPermutations(PropertyPermutations allPermutations,
+      List<String[]> values) {
     this.properties = allPermutations.properties;
     this.values = values;
   }
@@ -172,18 +180,17 @@
    */
   public List<PropertyPermutations> collapseProperties() {
     // Collate property values in this map
-    SortedMap<CollapsedPropertyKey, List<String[]>> map =
-        new TreeMap<CollapsedPropertyKey, List<String[]>>();
+    SortedMap<CollapsedPropertyKey, List<String[]>> map = new TreeMap<CollapsedPropertyKey, List<String[]>>();
 
     // Loop over all possible property value permutations
     for (Iterator<String[]> it = iterator(); it.hasNext();) {
       String[] propertyValues = it.next();
       assert propertyValues.length == getOrderedProperties().length;
 
-      StaticPropertyOracle oracle =
-          new StaticPropertyOracle(getOrderedProperties(), propertyValues,
-              new ConfigurationProperty[0]);
-      CollapsedPropertyKey key = new CollapsedPropertyKey(oracle);
+      StaticPropertyOracle oracle = new StaticPropertyOracle(
+          getOrderedProperties(), propertyValues, new ConfigurationProperty[0]);
+      CollapsedPropertyKey key = new CollapsedPropertyKey(
+          oracle);
 
       List<String[]> list = map.get(key);
       if (list == null) {
@@ -194,7 +201,8 @@
     }
 
     // Return the collated values
-    List<PropertyPermutations> toReturn = new ArrayList<PropertyPermutations>(map.size());
+    List<PropertyPermutations> toReturn = new ArrayList<PropertyPermutations>(
+        map.size());
     for (List<String[]> list : map.values()) {
       toReturn.add(new PropertyPermutations(this, list));
     }
@@ -222,34 +230,4 @@
   public int size() {
     return values.size();
   }
-
-  /**
-   * For debugging use only.
-   */
-  @Override
-  public String toString() {
-    StringBuilder sb = new StringBuilder();
-    sb.append("{");
-    boolean needsComma = false;
-    for (String[] strings : values) {
-      if (needsComma) {
-        sb.append(", ");
-      } else {
-        needsComma = true;
-      }
-      sb.append("[");
-      boolean innerNeedsComma = false;
-      for (String string : strings) {
-        if (innerNeedsComma) {
-          sb.append(", ");
-        } else {
-          innerNeedsComma = true;
-        }
-        sb.append(string);
-      }
-      sb.append("]");
-    }
-    sb.append("}");
-    return sb.toString();
-  }
 }
diff --git a/dev/core/test/com/google/gwt/dev/cfg/ModuleDefTest.java b/dev/core/test/com/google/gwt/dev/cfg/ModuleDefTest.java
index 8fcf69a..9827bd4 100644
--- a/dev/core/test/com/google/gwt/dev/cfg/ModuleDefTest.java
+++ b/dev/core/test/com/google/gwt/dev/cfg/ModuleDefTest.java
@@ -21,14 +21,13 @@
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.core.ext.linker.ArtifactSet;
 import com.google.gwt.core.ext.linker.LinkerOrder;
-import com.google.gwt.core.ext.linker.LinkerOrder.Order;
 import com.google.gwt.core.ext.linker.Shardable;
+import com.google.gwt.core.ext.linker.LinkerOrder.Order;
 
 import junit.framework.TestCase;
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 import java.util.SortedSet;
 
@@ -45,13 +44,14 @@
     }
 
     @Override
-    public ArtifactSet link(TreeLogger logger, LinkerContext context, ArtifactSet artifacts,
-        boolean onePermutation) {
+    public ArtifactSet link(TreeLogger logger, LinkerContext context,
+        ArtifactSet artifacts, boolean onePermutation) {
       return null;
     }
 
     @Override
-    public ArtifactSet relink(TreeLogger logger, LinkerContext context, ArtifactSet newArtifacts) {
+    public ArtifactSet relink(TreeLogger logger, LinkerContext context,
+        ArtifactSet newArtifacts) {
       return null;
     }
   }
@@ -120,10 +120,14 @@
 
     List<SortedSet<String>> collapsedValues = b.getCollapsedValues();
     assertEquals(4, collapsedValues.size());
-    assertEquals(Arrays.asList("a", "b"), new ArrayList<String>(collapsedValues.get(0)));
-    assertEquals(Arrays.asList("c", "d", "e"), new ArrayList<String>(collapsedValues.get(1)));
-    assertEquals(Arrays.asList("f1", "f2", "f3"), new ArrayList<String>(collapsedValues.get(2)));
-    assertEquals(Arrays.asList("g1a", "g2a"), new ArrayList<String>(collapsedValues.get(3)));
+    assertEquals(Arrays.asList("a", "b"), new ArrayList<String>(
+        collapsedValues.get(0)));
+    assertEquals(Arrays.asList("c", "d", "e"), new ArrayList<String>(
+        collapsedValues.get(1)));
+    assertEquals(Arrays.asList("f1", "f2", "f3"), new ArrayList<String>(
+        collapsedValues.get(2)));
+    assertEquals(Arrays.asList("g1a", "g2a"), new ArrayList<String>(
+        collapsedValues.get(3)));
 
     // Collapse everything
     b.addCollapsedValues("*");
@@ -131,79 +135,8 @@
 
     collapsedValues = b.getCollapsedValues();
     assertEquals(1, collapsedValues.size());
-    assertEquals(Arrays.asList(b.getDefinedValues()), new ArrayList<String>(collapsedValues.get(0)));
-  }
-
-  /**
-   * This tests the behavior of properties that depend on other properties with
-   * collapsed values. A dependency on a collapsed value forms an equivalent set
-   * for the dependent values. In other words, collapsing is contagious.
-   */
-  public void testCollapsedPropertiesWithDependencies() {
-    ModuleDef def = new ModuleDef("fake");
-    Properties p = def.getProperties();
-    // <define-property name="p1" values="a,b,c" />
-    BindingProperty p1 = p.createBinding("p1");
-    p1.addDefinedValue(p1.getRootCondition(), "a");
-    p1.addDefinedValue(p1.getRootCondition(), "b");
-    p1.addDefinedValue(p1.getRootCondition(), "c");
-    // <collapse-property name="p1" values="b,c" />
-    p1.addCollapsedValues("b", "c");
-
-    BindingProperty p2 = p.createBinding("p2");
-    // <define-property name="p2" values="d,e,f" />
-    p2.addDefinedValue(p2.getRootCondition(), "d");
-    p2.addDefinedValue(p2.getRootCondition(), "e");
-    p2.addDefinedValue(p2.getRootCondition(), "f");
-    /*-
-     * <set-property name="p2" values="e,f">
-     *  <when-property-is name="p1" value="c" />
-     * </set-property>
-     */
-    p2.setAllowedValues(new ConditionWhenPropertyIs("p1", "c"), "e", "f");
-
-    /*
-     * The net effect of the above is to delete the [c,d] permutation and to
-     * make the e and f values dependent on the c value. Because c is a
-     * collapsed value, e and f are then automatically collapsed together when
-     * p2 is normalized.
-     */
-
-    p1.normalizeCollapsedValues();
-    p2.normalizeCollapsedValues();
-
-    PropertyPermutations perms = new PropertyPermutations(p, Collections.<String> emptySet());
-    List<PropertyPermutations> hardPerms = perms.collapseProperties();
-
-    assertEquals(4, hardPerms.size());
-    {
-      // {[a,d]}
-      PropertyPermutations perm = hardPerms.get(0);
-      assertEquals(1, perm.size());
-      assertEquals(Arrays.asList("a", "d"), Arrays.asList(perm.getOrderedPropertyValues(0)));
-    }
-    {
-      // {[a,e], [a,f]}
-      PropertyPermutations perm = hardPerms.get(1);
-      assertEquals(2, perm.size());
-      assertEquals(Arrays.asList("a", "e"), Arrays.asList(perm.getOrderedPropertyValues(0)));
-      assertEquals(Arrays.asList("a", "f"), Arrays.asList(perm.getOrderedPropertyValues(1)));
-    }
-    {
-      // {[b,d]}
-      PropertyPermutations perm = hardPerms.get(2);
-      assertEquals(1, perm.size());
-      assertEquals(Arrays.asList("b", "d"), Arrays.asList(perm.getOrderedPropertyValues(0)));
-    }
-    {
-      // {[b,e], [b,f], [c,e], [c,f]}
-      PropertyPermutations perm = hardPerms.get(3);
-      assertEquals(4, perm.size());
-      assertEquals(Arrays.asList("b", "e"), Arrays.asList(perm.getOrderedPropertyValues(0)));
-      assertEquals(Arrays.asList("b", "f"), Arrays.asList(perm.getOrderedPropertyValues(1)));
-      assertEquals(Arrays.asList("c", "e"), Arrays.asList(perm.getOrderedPropertyValues(2)));
-      assertEquals(Arrays.asList("c", "f"), Arrays.asList(perm.getOrderedPropertyValues(3)));
-    }
+    assertEquals(Arrays.asList(b.getDefinedValues()), new ArrayList<String>(
+        collapsedValues.get(0)));
   }
 
   public void testLinkerOrder() throws UnableToCompleteException {
@@ -221,14 +154,13 @@
     def.addLinker("post2");
     def.addLinker("primary");
 
-    Class<?>[] expectedClasses =
-        {
-            FakeLinkerPre2.class, FakeLinkerPre.class, FakeLinkerPost.class, FakeLinkerPost2.class,
-            FakeLinkerPrimary.class};
+    Class<?>[] expectedClasses = {
+        FakeLinkerPre2.class, FakeLinkerPre.class, FakeLinkerPost.class,
+        FakeLinkerPost2.class, FakeLinkerPrimary.class};
     assertEquals(FakeLinkerPrimary.class, def.getActivePrimaryLinker());
     // Test iteration order
-    assertEquals(Arrays.asList(expectedClasses), new ArrayList<Class<? extends Linker>>(def
-        .getActiveLinkers()));
+    assertEquals(Arrays.asList(expectedClasses),
+        new ArrayList<Class<? extends Linker>>(def.getActiveLinkers()));
   }
 
   public void testLinkerRedefinition() throws UnableToCompleteException {
@@ -247,12 +179,12 @@
     // Intentional duplication
     def.addLinker("post");
 
-    Class<?>[] expectedClasses =
-        {FakeLinkerPre2.class, FakeLinkerPost2.class, FakeLinkerPrimary2.class};
+    Class<?>[] expectedClasses = {
+        FakeLinkerPre2.class, FakeLinkerPost2.class, FakeLinkerPrimary2.class};
     assertEquals(FakeLinkerPrimary2.class, def.getActivePrimaryLinker());
     // Test iteration order
-    assertEquals(Arrays.asList(expectedClasses), new ArrayList<Class<? extends Linker>>(def
-        .getActiveLinkers()));
+    assertEquals(Arrays.asList(expectedClasses),
+        new ArrayList<Class<? extends Linker>>(def.getActiveLinkers()));
   }
 
   public void testLinkerRedefinitionErrors() throws UnableToCompleteException {
@@ -298,12 +230,12 @@
     def.addLinker("primary");
     def.addLinker("primary2");
 
-    Class<?>[] expectedClasses =
-        {FakeLinkerPre.class, FakeLinkerPost.class, FakeLinkerPrimary2.class};
+    Class<?>[] expectedClasses = {
+        FakeLinkerPre.class, FakeLinkerPost.class, FakeLinkerPrimary2.class};
     assertEquals(FakeLinkerPrimary2.class, def.getActivePrimaryLinker());
     // Test iteration order
-    assertEquals(Arrays.asList(expectedClasses), new ArrayList<Class<? extends Linker>>(def
-        .getActiveLinkers()));
+    assertEquals(Arrays.asList(expectedClasses),
+        new ArrayList<Class<? extends Linker>>(def.getActiveLinkers()));
   }
 
   public void testValidModuleName() {
@@ -312,15 +244,15 @@
     assertFalse(ModuleDef.isValidModuleName("com..Foo"));
     assertFalse(ModuleDef.isValidModuleName("com.7.Foo"));
     assertFalse(ModuleDef.isValidModuleName("com.7foo.Foo"));
-
+    
     assertTrue(ModuleDef.isValidModuleName("com.foo.Foo"));
     assertTrue(ModuleDef.isValidModuleName("com.$foo.Foo"));
     assertTrue(ModuleDef.isValidModuleName("com._foo.Foo"));
     assertTrue(ModuleDef.isValidModuleName("com.foo7.Foo"));
-
-    // For legacy reasons, allow the last part of the name is not
-    // required to be a valid ident. In the past, naming rules
-    // were enforced for top level modules, but not nested modules.
+    
+    // For legacy reasons, allow the last part of the name is not 
+    // required to be a valid ident.  In the past, naming rules 
+    // were enforced for top level modules, but not nested modules.    
     assertTrue(ModuleDef.isValidModuleName("com.foo.F-oo"));
     assertTrue(ModuleDef.isValidModuleName("com.foo.7Foo"));
     assertTrue(ModuleDef.isValidModuleName("com.foo.+Foo"));