diff --git a/common.ant.xml b/common.ant.xml
index 2e2c78a..8a65f84 100755
--- a/common.ant.xml
+++ b/common.ant.xml
@@ -174,6 +174,8 @@
           <pathelement location="${gwt.dev.staging.jar}" />
           <pathelement location="${gwt.tools.lib}/junit/junit-3.8.1.jar" />
           <pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" />
+          <pathelement location="${gwt.tools.lib}/w3c/sac/sac-1.3.jar" />
+          <pathelement location="${gwt.tools.lib}/w3c/flute/flute-1.3.jar" />
           <extraclasspaths />
         </classpath>
 
diff --git a/dev/core/src/com/google/gwt/core/ext/Generator.java b/dev/core/src/com/google/gwt/core/ext/Generator.java
index 1e5e470..524dddb 100644
--- a/dev/core/src/com/google/gwt/core/ext/Generator.java
+++ b/dev/core/src/com/google/gwt/core/ext/Generator.java
@@ -31,6 +31,7 @@
     int extra = 0;
     for (int in = 0, n = unescaped.length(); in < n; ++in) {
       switch (unescaped.charAt(in)) {
+        case '\0':
         case '\n':
         case '\r':
         case '\"':
@@ -49,6 +50,10 @@
     for (int in = 0, out = 0, n = oldChars.length; in < n; ++in, ++out) {
       char c = oldChars[in];
       switch (c) {
+        case '\0':
+          newChars[out++] = '\\';
+          c = '0';
+          break;
         case '\n':
           newChars[out++] = '\\';
           c = 'n';
diff --git a/eclipse/user/.classpath b/eclipse/user/.classpath
index 60629c2..3f063b0 100644
--- a/eclipse/user/.classpath
+++ b/eclipse/user/.classpath
@@ -8,6 +8,8 @@
 	<classpathentry exported="true" kind="var" path="GWT_TOOLS/lib/junit/junit-3.8.1.jar" sourcepath="/GWT_TOOLS/lib/junit/junit-3.8.1-src.zip"/>
 	<classpathentry exported="true" kind="var" path="GWT_TOOLS/lib/tomcat/servlet-api-2.5.jar"/>
 	<classpathentry kind="var" path="GWT_TOOLS/lib/selenium/selenium-java-client-driver.jar"/>
+	<classpathentry kind="var" path="GWT_TOOLS/lib/w3c/sac/sac-1.3.jar"/>
+	<classpathentry kind="var" path="GWT_TOOLS/lib/w3c/flute/flute-1.3.jar"/>
 	<classpathentry combineaccessrules="false" kind="src" path="/gwt-dev-windows"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/user/build.xml b/user/build.xml
index 196959a..2ff72cb 100755
--- a/user/build.xml
+++ b/user/build.xml
@@ -35,6 +35,8 @@
         <pathelement location="${gwt.tools.lib}/junit/junit-3.8.1.jar" />
         <pathelement location="${gwt.tools.lib}/jfreechart/jfreechart-1.0.3.jar" />
         <pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" />
+        <pathelement location="${gwt.tools.lib}/w3c/sac/sac-1.3.jar" />
+        <pathelement location="${gwt.tools.lib}/w3c/flute/flute-1.3.jar" />
         <pathelement location="${gwt.dev.jar}" />
       </classpath>
     </gwt.javac>
@@ -73,6 +75,8 @@
       <fileset dir="super" excludes="**/package.html" />
       <fileset dir="${javac.out}" />
       <zipfileset src="${gwt.tools.lib}/tomcat/servlet-api-2.5.jar" />
+      <zipfileset src="${gwt.tools.lib}/w3c/sac/sac-1.3.jar" />
+      <zipfileset src="${gwt.tools.lib}/w3c/flute/flute-1.3.jar" />
     </gwt.jar>
   </target>
 
diff --git a/user/src/com/google/gwt/resources/Resources.gwt.xml b/user/src/com/google/gwt/resources/Resources.gwt.xml
new file mode 100644
index 0000000..482d555
--- /dev/null
+++ b/user/src/com/google/gwt/resources/Resources.gwt.xml
@@ -0,0 +1,75 @@
+<!--                                                                        -->
+<!-- Copyright 2008 Google Inc.                                             -->
+<!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
+<!-- may not use this file except in compliance with the License. You may   -->
+<!-- may obtain a copy of the License at                                    -->
+<!--                                                                        -->
+<!-- http://www.apache.org/licenses/LICENSE-2.0                             -->
+<!--                                                                        -->
+<!-- Unless required by applicable law or agreed to in writing, software    -->
+<!-- distributed under the License is distributed on an "AS IS" BASIS,      -->
+<!-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        -->
+<!-- implied. License for the specific language governing permissions and   -->
+<!-- limitations under the License.                                         -->
+
+<!-- ClientBundle supports renaming files with strong names at compile time  -->
+<module>
+  <!-- Pull in the necessary base support, including user.agent detection -->
+  <inherits name="com.google.gwt.core.Core" />
+  <!-- Used by ExternalTextResource -->
+  <inherits name="com.google.gwt.http.HTTP" />
+
+  <!--  This acts as a switch to disable the use of data: URLs -->
+  <define-property name="ClientBundle.enableInlining" values="true,false" />
+  <set-property name="ClientBundle.enableInlining" value="true" />
+
+  <!-- Specify the default behavior -->
+  <generate-with
+    class="com.google.gwt.resources.rebind.context.StaticClientBundleGenerator">
+
+    <!-- We have to specify on which types to execute the Generator -->
+    <when-type-assignable
+      class="com.google.gwt.resources.client.ClientBundle" />
+  </generate-with>
+
+  <!-- Last-matches wins, so this will selectively override the previous rule -->
+  <generate-with
+    class="com.google.gwt.resources.rebind.context.InlineClientBundleGenerator">
+
+    <!-- We have a number of conditions that must be satisfied -->
+    <all>
+      <!-- Is inlining enabled? -->
+      <when-property-is name="ClientBundle.enableInlining" value="true" />
+
+      <!-- Again, it's necessary to specify which types the generator runs on -->
+      <when-type-assignable
+        class="com.google.gwt.resources.client.ClientBundle" />
+
+      <!-- Only some browsers support RFC 2397 data: URLs -->
+      <any>
+        <when-property-is name="user.agent" value="safari" />
+        <when-property-is name="user.agent" value="opera" />
+        <when-property-is name="user.agent" value="gecko" />
+        <when-property-is name="user.agent" value="gecko1_8" />
+      </any>
+    </all>
+  </generate-with>
+
+  <!-- This can be used to disable the use of strongly-named files -->
+  <set-configuration-property name="ClientBundle.enableRenaming" value="true" />
+
+  <!-- This allows merging of CSS rules to be disabled. -->
+  <set-configuration-property name="CssResource.mergeEnabled" value="true" />
+
+  <!-- This forces all CssResource accessor functions to have the @Strict -->
+  <!-- annotation. This is intended primarily for application developers and -->
+  <!-- the library test code. -->
+  <set-configuration-property name="CssResource.strictAccessors" value="false" />
+
+  <!-- This allows the developer to use shorter obfuscated class names. -->
+  <!-- Is is valid to extend this property to use a custom name. -->
+  <set-configuration-property name="CssResource.obfuscationPrefix" value="default" />
+
+  <!-- This can be used to make CssResource produce human-readable CSS -->
+  <set-configuration-property name="CssResource.style" value="obf" />
+</module>
diff --git a/user/src/com/google/gwt/resources/client/ClientBundle.java b/user/src/com/google/gwt/resources/client/ClientBundle.java
new file mode 100644
index 0000000..a25cba5
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/ClientBundle.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.resources.ext.ResourceGeneratorType;
+import com.google.gwt.resources.rg.BundleResourceGenerator;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * The use of this interface is similar to that of ImageBundle. Declare
+ * no-argument functions that return subclasses of {@link ResourcePrototype},
+ * which are annotated with {@link ClientBundle.Source} annotations specifying
+ * the classpath location of the resource to include in the output. At runtime,
+ * the functions will return an object that can be used to access the data in
+ * the original resource.
+ */
+@ResourceGeneratorType(BundleResourceGenerator.class)
+public interface ClientBundle {
+  /**
+   * Specifies the classpath location of the resource or resources associated
+   * with the {@link ResourcePrototype}.
+   */
+  @Target(ElementType.METHOD)
+  public @interface Source {
+    String[] value();
+  }
+}
diff --git a/user/src/com/google/gwt/resources/client/ClientBundleWithLookup.java b/user/src/com/google/gwt/resources/client/ClientBundleWithLookup.java
new file mode 100644
index 0000000..90a7b6e
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/ClientBundleWithLookup.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+/**
+ * This is an extension of ClientBundle that allows for name-based lookup of
+ * resources. Note that the use of the methods defined within this interface
+ * will prevent the compiler from pruning any of the resources declared in the
+ * ClientBundle.
+ */
+public interface ClientBundleWithLookup extends ClientBundle {
+
+  /**
+   * Find a resource by the name of the function in which it is declared.
+   * 
+   * @param name the name of the desired resource
+   * @return the resource, or <code>null</code> if no such resource is defined.
+   */
+  ResourcePrototype getResource(String name);
+
+  /**
+   * A convenience method to iterate over all ResourcePrototypes contained in
+   * the ClientBundle.
+   */
+  ResourcePrototype[] getResources();
+}
diff --git a/user/src/com/google/gwt/resources/client/CssResource.java b/user/src/com/google/gwt/resources/client/CssResource.java
new file mode 100644
index 0000000..a133977
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/CssResource.java
@@ -0,0 +1,254 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.resources.ext.ResourceGeneratorType;
+import com.google.gwt.resources.rg.CssResourceGenerator;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * Aggregates and minifies CSS stylesheets. A CssResource represents a regular
+ * CSS file with GWT-specific at-rules.
+ * <p>
+ * Currently-supported accessor functions:
+ * 
+ * <ul>
+ * <li>{@code String someClassName();} will allow the css class
+ * <code>.someClassName</code> to be obfuscated at runtime. The function will
+ * return the obfuscated class name.</li>
+ * <li>{@code <primitive numeric type> someDefName();} will allow access to the
+ * values defined by {@literal @def} rules within the CSS file. The defined
+ * value must be a raw number, a CSS length, or a percentage value.
+ * </ul>
+ * 
+ * <p>
+ * Currently-supported rules:
+ * 
+ * <ul>
+ * <li>{@code @def NAME replacement-expression; .myClass background: NAME;}
+ * Define a static constant. The replacement expression may be any CSS that
+ * would be valid in a property value context. A {@code @def} may refer to
+ * previously-defined rules, but no forward-references will be honored.</li>
+ * <li>{@code @eval NAME Java-expression; .myClass background: NAME;} Define a
+ * constant based on a Java expression.</li>
+ * <li><code>{@literal @if} [!]property list of values {ruleBlock}</code> Include or
+ * exclude CSS rules based on the value of a deferred-binding property. Also
+ * {@code @elif} and {@code @else} follow the same pattern.<br/>
+ * This might look like {@code @if user.agent ie6 safari ...}.</li>
+ * <li><code>{@literal @if} (Java-expression) {ruleBlock}</code> Include or exclude
+ * CSS rules based on a boolean Java expression.</li>
+ * <li><code>{@literal @noflip} { rules }</code> will suppress the automatic
+ * right-to-left transformation applied to the CSS when the module is compiled
+ * for an RTL language.</li>
+ * <li>
+ * <code>{@literal @}sprite .any .selector {gwt-image: "imageResourceFunction";}</code>
+ * . The appearance, size, and height of the sprite will be affected by any
+ * {@link ImageResource.ImageOptions} annotations present on the related
+ * {@link ImageResource} accessor function. Additional properties may be
+ * specified in the rule block.</li>
+ * <li>{@code @url NAME siblingDataResource; .myClass background: NAME
+ * repeat-x;} Use a {@link DataResource} to generate a <code>url('...'}</code> value.</li>
+ * </ul>
+ * 
+ * <p>
+ * Currently-supported CSS functions:
+ * 
+ * <ul>
+ * <li>{@code literal("expression")} substitutes a property value that does not
+ * conform to CSS2 parsing rules. The escape sequences {@code \"} and {@code \\}
+ * will be replaced with {@code "} and {@code \} respectively.
+ * <li>{@code value("bundleFunction.someFunction[.other[...]]" [, "suffix"])}
+ * substitute the value of a sequence of named zero-arg function invocations. An
+ * optional suffix will be appended to the return value of the function. The
+ * first name is resolved relative to the bundle interface passed to
+ * {@link com.google.gwt.core.client.GWT#create(Class)}. An example:
+ * 
+ * <pre>
+ * .bordersTheSizeOfAnImage {
+ *   border-left: value('leftBorderImageResource.getWidth', 'px') solid blue;
+ * }
+ * </pre>
+ * </li>
+ * </ul>
+ * 
+ * @see <a
+ *      href="http://code.google.com/p/google-web-toolkit-incubator/wiki/CssResource"
+ *      >CssResource design doc</a>
+ */
+@ResourceGeneratorType(CssResourceGenerator.class)
+public interface CssResource extends ResourcePrototype {
+  /**
+   * The original CSS class name specified in the resource. This allows CSS
+   * classes that do not correspond to Java identifiers to be mapped onto
+   * obfuscated class accessors.
+   * 
+   * <pre>
+   * .some-non-java-ident { background: blue; }
+   * 
+   * interface MyCssResource extends CssResource {
+   *   {@literal @}ClassName("some-non-java-ident")
+   *   String classAccessor();
+   * }
+   * </pre>
+   */
+  @Documented
+  @Target(ElementType.METHOD)
+  public @interface ClassName {
+    String value();
+  }
+
+  /**
+   * Makes class selectors from other CssResource types available in the raw
+   * source of a CssResource. String accessor methods can be referred to using
+   * the value of the imported type's {@link ImportedWithPrefix} value.
+   * <p>
+   * This is an example of creating a descendant selector with two unrelated
+   * types:
+   * 
+   * <pre>
+   *{@literal @ImportedWithPrefix}("some-prefix")
+   * interface ToImport extends CssResource {
+   *   String widget();
+   * }
+   * 
+   *{@literal @ImportedWithPrefix}("other-import")
+   * interface OtherImport extends CssResource {
+   *   String widget();
+   * }
+   * 
+   * interface Resources extends ClientBundle {
+   *  {@literal @Import}(value = {ToImport.class, OtherImport.class})
+   *  {@literal @Source}("my.css")
+   *   CssResource usesImports();
+   * }
+   * 
+   * my.css:
+   * // Now I can refer to these classes defined elsewhere with no 
+   * // fear of name collisions
+   * .some-prefix-widget .other-import-widget {...}
+   * </pre>
+   * 
+   * If the imported CssResource type is lacking an {@link ImportedWithPrefix}
+   * annotation, the simple name of the type will be used instead. In the above
+   * example, without the annotation on <code>ToImport</code>, the class
+   * selector would have been <code>.ToImport-widget</code>. Notice also that
+   * both interfaces defined a method called <code>widget()</code>, which would
+   * prevent meaningful composition of the original interfaces.
+   * <p>
+   * It is an error to import multiple classes with the same prefix into one
+   * CssResource.
+   */
+  @Documented
+  @Target(ElementType.METHOD)
+  public @interface Import {
+    Class<? extends CssResource>[] value();
+  }
+
+  /**
+   * Specifies the string prefix to use when one CssResource is imported into
+   * the scope of another CssResource.
+   * 
+   * @see Import
+   */
+  @Documented
+  @Target(ElementType.TYPE)
+  public @interface ImportedWithPrefix {
+    String value();
+  }
+
+  /**
+   * Indicates that the String accessor methods defined in a CssResource will
+   * return the same values across all implementations of that type.
+   * <p>
+   * This is an example of "stateful" class selectors being used:
+   * 
+   * <pre>
+   *{@literal @Shared}
+   * interface FocusCss extends CssResource {
+   *   String focused();
+   *   String unfocused();
+   * }
+   * 
+   * interface PanelCss extends CssResource, FocusCss {
+   *   String widget();
+   * }
+   * 
+   * interface InputCss extends CssResource, FocusCss {
+   *   String widget();
+   * }
+   * 
+   * input.css:
+   * *.focused .widget {border: thin solid blue;}
+   * 
+   * Application.java:
+   * myPanel.add(myInputWidget);
+   * myPanel.addStyleName(instanceOfPanelCss.focused());
+   * </pre>
+   * 
+   * Because the <code>FocusCss</code> interface is tagged with {@code @Shared},
+   * the <code>focused()</code> method on the instance of <code>PanelCss</code>
+   * will match the <code>.focused</code> parent selector in
+   * <code>input.css</code>.
+   * <p>
+   * The effect of inheriting an {@code Shared} interface can be replicated by
+   * use use of the {@link Import} annotation (e.g. {@code .FocusCss-focused
+   * .widget}), however the use of state-bearing descendant selectors is common
+   * enough to warrant an easier use-case.
+   */
+  @Documented
+  @Target(ElementType.TYPE)
+  public @interface Shared {
+  }
+
+  /**
+   * The presence of this annotation on a CssResource accessor method indicates
+   * that any class selectors that do not correspond with a String accessor
+   * method in the return type should trigger a compilation error. In the normal
+   * case, any unobfuscatable class selectors will be emitted as-is. This
+   * annotation ensures that the resource does not contribute any unobfuscated
+   * class selectors into the global CSS namespace and is recommended as the
+   * default for library-provided CssResource instances.
+   * <p>
+   * Given these interfaces:
+   * 
+   * <pre>
+   * interface MyCss extends CssResource {
+   *   String someClass();
+   * }
+   * 
+   * interface MyBundle extends ClientBundle {
+   *  {@literal @Source("my.css")}
+   *  {@literal @Strict}
+   *   MyCss css();
+   * }
+   * </pre>
+   * 
+   * the source CSS will fail to compile if it does not contain exactly the one
+   * class selector defined in the MyCss type.
+   */
+  @Documented
+  @Target(ElementType.METHOD)
+  public @interface Strict {
+  }
+
+  /**
+   * Provides the contents of the CssResource.
+   */
+  String getText();
+}
diff --git a/user/src/com/google/gwt/resources/client/DataResource.java b/user/src/com/google/gwt/resources/client/DataResource.java
new file mode 100644
index 0000000..fd3d2cb
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/DataResource.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.resources.ext.ResourceGeneratorType;
+import com.google.gwt.resources.rg.DataResourceGenerator;
+
+/**
+ * A non-text resource.
+ */
+@ResourceGeneratorType(DataResourceGenerator.class)
+public interface DataResource extends ResourcePrototype {
+  /**
+   * Retrieves a URL by which the contents of the resource can be obtained. This
+   * will be an absolute URL.
+   */
+  String getUrl();
+}
diff --git a/user/src/com/google/gwt/resources/client/ExternalTextResource.java b/user/src/com/google/gwt/resources/client/ExternalTextResource.java
new file mode 100644
index 0000000..0e5d4cb
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/ExternalTextResource.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.resources.ext.ResourceGeneratorType;
+import com.google.gwt.resources.rg.ExternalTextResourceGenerator;
+
+/**
+ * Identical to {@link TextResource}, except the contents of the resource are
+ * not inlined into the compiled output. This is suitable for resources that are
+ * not required as part of program initialization.
+ */
+@ResourceGeneratorType(ExternalTextResourceGenerator.class)
+public interface ExternalTextResource extends ResourcePrototype {
+  void getText(ResourceCallback<TextResource> callback)
+      throws ResourceException;
+}
diff --git a/user/src/com/google/gwt/resources/client/GwtCreateResource.java b/user/src/com/google/gwt/resources/client/GwtCreateResource.java
new file mode 100644
index 0000000..a13b32a
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/GwtCreateResource.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.resources.ext.ResourceGeneratorType;
+import com.google.gwt.resources.rg.GwtCreateResourceGenerator;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * This resource type allows any class that can be instantiated via a call to
+ * {@link com.google.gwt.core.client.GWT#create(Class)} to be used within an
+ * ClientBundle. Example uses include the I18N support classes, RPC
+ * endpoints, or any type that supports default instantiation. If no
+ * {@link ClassType} annotation is present on the resource accessor method, the
+ * type parameter <code>T</code> will be used as the class literal passed to
+ * <code>GWT.create()</code>.
+ * 
+ * @param <T> The type that should be returned from the
+ *          <code>GWT.create()</code> call
+ */
+@ResourceGeneratorType(GwtCreateResourceGenerator.class)
+public interface GwtCreateResource<T> extends ResourcePrototype {
+  /**
+   * This annotation can be applied to the resource getter method in order to
+   * call <code>GWT.create</code> with a class literal other than that of the
+   * return type parameterization. This annotation would be used with RPC
+   * endpoints:
+   * 
+   * <pre>{@literal @ClassType}(Service.class)
+   * GwtCreateResource&lt;ServiceAsync&gt; rpc();
+   * </pre>
+   */
+  @Documented
+  @Target(ElementType.METHOD)
+  public @interface ClassType {
+    Class<?> value();
+  }
+
+  /**
+   * Invokes <code>GWT.create()</code>. Multiple invocations of this method will
+   * return different instances of the <code>T</code> type.
+   */
+  T create();
+}
diff --git a/user/src/com/google/gwt/resources/client/ImageResource.java b/user/src/com/google/gwt/resources/client/ImageResource.java
new file mode 100644
index 0000000..75c2572
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/ImageResource.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.resources.ext.ResourceGeneratorType;
+import com.google.gwt.resources.rg.ImageResourceGenerator;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * Provides access to image resources at runtime.
+ */
+@ResourceGeneratorType(ImageResourceGenerator.class)
+public interface ImageResource extends ResourcePrototype {
+
+  /**
+   * Specifies additional options to control how an image is bundled.
+   */
+  @Documented
+  @Target(ElementType.METHOD)
+  public @interface ImageOptions {
+    /**
+     * This option affects the image bundling optimization to allow the image to
+     * be used with the {@link CssResource} {@code @sprite} rule where
+     * repetition of the image is desired.
+     * 
+     * @see "CssResource documentation"
+     */
+    RepeatStyle repeatStyle() default RepeatStyle.None;
+
+    /**
+     * If <code>true</code>, the image will be flipped along the y-axis when
+     * {@link com.google.gwt.i18n.client.LocaleInfo#isRTL()} returns
+     * <code>true</code>. This is intended to be used by graphics that are
+     * sensitive to layout direction, such as arrows and disclosure indicators.
+     */
+    boolean flipRtl() default false;
+  }
+
+  /**
+   * Indicates that an ImageResource should be bundled in such a way as to
+   * support horizontal or vertical repetition.
+   */
+  public enum RepeatStyle {
+    /**
+     * The image is not intended to be tiled.
+     */
+    None,
+
+    /**
+     * The image is intended to be tiled horizontally.
+     */
+    Horizontal,
+
+    /**
+     * The image is intended to be tiled vertically.
+     */
+    Vertical,
+
+    /**
+     * The image is intended to be tiled both horizontally and vertically. Note
+     * that this will prevent compositing of the particular image in most cases.
+     */
+    Both
+  }
+
+  /**
+   * Returns the height of the image.
+   */
+  int getHeight();
+
+  /**
+   * Returns the horizontal position of the image within the composite image.
+   */
+  int getLeft();
+
+  /**
+   * Returns the vertical position of the image within the composite image.
+   */
+  int getTop();
+
+  /**
+   * Returns the URL for the composite image that contains the ImageResource.
+   */
+  String getURL();
+
+  /**
+   * Returns the width of the image.
+   */
+  int getWidth();
+}
diff --git a/user/src/com/google/gwt/resources/client/ResourceCallback.java b/user/src/com/google/gwt/resources/client/ResourceCallback.java
new file mode 100644
index 0000000..a08e5fc
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/ResourceCallback.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+/**
+ * A callback interface for asynchronous operations on resources.
+ * 
+ * @param <R> the type of resource
+ */
+public interface ResourceCallback<R extends ResourcePrototype> {
+  /**
+   * Invoked if the asynchronous operation failed.
+   * @param e an exception describing the failure
+   */
+  void onError(ResourceException e);
+
+  /**
+   * Invoked if the asynchronous operation was successfully completed.
+   * @param resource the resource on which the operation was performed
+   */
+  void onSuccess(R resource);
+}
diff --git a/user/src/com/google/gwt/resources/client/ResourceException.java b/user/src/com/google/gwt/resources/client/ResourceException.java
new file mode 100644
index 0000000..797632a
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/ResourceException.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2007 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+/**
+ * Associates a {@link ResourcePrototype} with a program error.
+ */
+public class ResourceException extends Exception {
+  private final ResourcePrototype resource;
+
+  public ResourceException(ResourcePrototype resource) {
+    this.resource = resource;
+  }
+
+  public ResourceException(ResourcePrototype resource, String msg) {
+    super(msg);
+    this.resource = resource;
+  }
+
+  public ResourceException(ResourcePrototype resource, String msg, Throwable t) {
+    super(msg, t);
+    this.resource = resource;
+  }
+
+  public ResourcePrototype getResource() {
+    return resource;
+  }
+}
diff --git a/user/src/com/google/gwt/resources/client/ResourcePrototype.java b/user/src/com/google/gwt/resources/client/ResourcePrototype.java
new file mode 100644
index 0000000..81cc6e4
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/ResourcePrototype.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+/**
+ * The base interface all bundle resource types must extend.
+ */
+public interface ResourcePrototype {
+  /**
+   * Returns the name of the function within the ClientBundle used to create the
+   * ResourcePrototype.
+   * 
+   * @return the name of the function within the ClientBundle used to create the
+   *         ResourcePrototype
+   */
+  String getName();
+}
diff --git a/user/src/com/google/gwt/resources/client/TextResource.java b/user/src/com/google/gwt/resources/client/TextResource.java
new file mode 100644
index 0000000..69ee17a
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/TextResource.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.resources.ext.ResourceGeneratorType;
+import com.google.gwt.resources.rg.TextResourceGenerator;
+
+/**
+ * A resource that contains text that should be incorporated into the compiled
+ * output.
+ */
+@ResourceGeneratorType(TextResourceGenerator.class)
+public interface TextResource extends ResourcePrototype {
+  String getText();
+}
diff --git a/user/src/com/google/gwt/resources/client/TextResourceCallback.java b/user/src/com/google/gwt/resources/client/TextResourceCallback.java
new file mode 100644
index 0000000..beac520
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/TextResourceCallback.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+/**
+ * A callback used when loading external text resources.
+ * @deprecated use {@link ResourceCallback} directly
+ */
+@Deprecated
+public interface TextResourceCallback extends ResourceCallback<TextResource> {
+}
diff --git a/user/src/com/google/gwt/resources/client/impl/ExternalTextResourcePrototype.java b/user/src/com/google/gwt/resources/client/impl/ExternalTextResourcePrototype.java
new file mode 100644
index 0000000..c76ae01
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/impl/ExternalTextResourcePrototype.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client.impl;
+
+import com.google.gwt.core.client.JavaScriptObject;
+import com.google.gwt.http.client.Request;
+import com.google.gwt.http.client.RequestBuilder;
+import com.google.gwt.http.client.RequestCallback;
+import com.google.gwt.http.client.RequestException;
+import com.google.gwt.http.client.Response;
+import com.google.gwt.resources.client.ExternalTextResource;
+import com.google.gwt.resources.client.ResourceCallback;
+import com.google.gwt.resources.client.ResourceException;
+import com.google.gwt.resources.client.TextResource;
+
+/**
+ * Implements external resource fetching of TextResources.
+ */
+public class ExternalTextResourcePrototype implements ExternalTextResource {
+
+  /**
+   * Maps the HTTP callback onto the ResourceCallback.
+   */
+  private class ETRCallback implements RequestCallback {
+    final ResourceCallback<TextResource> callback;
+
+    public ETRCallback(ResourceCallback<TextResource> callback) {
+      this.callback = callback;
+    }
+
+    public void onError(Request request, Throwable exception) {
+      callback.onError(new ResourceException(
+          ExternalTextResourcePrototype.this,
+          "Unable to retrieve external resource", exception));
+    }
+
+    public void onResponseReceived(Request request, final Response response) {
+      // Get the contents of the JSON bundle
+      String responseText = response.getText();
+
+      // Call eval() on the object.
+      JavaScriptObject jso = evalObject(responseText);
+      if (jso == null) {
+        callback.onError(new ResourceException(
+            ExternalTextResourcePrototype.this, "eval() returned null"));
+        return;
+      }
+
+      // Populate the TextResponse cache array
+      for (int i = 0; i < cache.length; i++) {
+        final String resourceText = extractString(jso, i);
+        cache[i] = new TextResource() {
+
+          public String getName() {
+            return name;
+          }
+
+          public String getText() {
+            return resourceText;
+          }
+
+        };
+      }
+
+      // Finish by invoking the callback
+      callback.onSuccess(cache[index]);
+    }
+  }
+
+  /**
+   * Evaluate the JSON payload. The regular expression to validate the safety of
+   * the payload is taken from RFC 4627 (D. Crockford).
+   * 
+   * @param data the raw JSON-encapsulated string bundle
+   * @return the evaluated JSON object, or <code>null</code> if there is an
+   *         error.
+   */
+  private static native JavaScriptObject evalObject(String data) /*-{
+    var safe = !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
+      data.replace(/"(\\.|[^"\\])*"/g, '')));
+
+    if (!safe) {
+      return null;
+    }
+
+    return eval('(' + data + ')') || null;
+  }-*/;
+
+  /**
+   * Extract the specified String from a JavaScriptObject that is array-like.
+   * 
+   * @param jso the JavaScriptObject returned from {@link #evalObject(String)}
+   * @param index the index of the string to extract
+   * @return the requested string, or <code>null</code> if it does not exist.
+   */
+  private static native String extractString(JavaScriptObject jso, int index) /*-{
+    return (jso.length > index) && jso[index] || null;
+  }-*/;
+
+  /**
+   * This is a reference to an array nominally created in the IRB that contains
+   * the ExternalTextResource. It is intended to be shared between all instances
+   * of the ETR that have a common parent IRB.
+   */
+  private final TextResource[] cache;
+  private final int index;
+  private final String name;
+  private final String url;
+
+  public ExternalTextResourcePrototype(String name, String url,
+      TextResource[] cache, int index) {
+    this.name = name;
+    this.url = url;
+    this.cache = cache;
+    this.index = index;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  /**
+   * Possibly fire off an HTTPRequest for the text resource.
+   */
+  public void getText(ResourceCallback<TextResource> callback)
+      throws ResourceException {
+
+    // If we've already parsed the JSON bundle, short-circuit.
+    if (cache[index] != null) {
+      callback.onSuccess(cache[index]);
+      return;
+    }
+
+    // Otherwise, fire an HTTP request.
+    RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, url);
+    try {
+      rb.sendRequest("", new ETRCallback(callback));
+    } catch (RequestException e) {
+      throw new ResourceException(this,
+          "Unable to initiate request for external resource", e);
+    }
+  }
+}
diff --git a/user/src/com/google/gwt/resources/client/impl/ImageResourcePrototype.java b/user/src/com/google/gwt/resources/client/impl/ImageResourcePrototype.java
new file mode 100644
index 0000000..11bcd64
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/impl/ImageResourcePrototype.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2007 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client.impl;
+
+import com.google.gwt.resources.client.ImageResource;
+
+/**
+ * This is part of an implementation of the ImageBundle optimization implemented
+ * with ClientBundle.
+ */
+public class ImageResourcePrototype implements ImageResource {
+
+  private final String name;
+  private final String url;
+  private final int left;
+  private final int top;
+  private final int width;
+  private final int height;
+
+  public ImageResourcePrototype(String name, String url, int left, int top,
+      int width, int height) {
+    this.name = name;
+    this.left = left;
+    this.top = top;
+    this.height = height;
+    this.width = width;
+    this.url = url;
+  }
+
+  /**
+   * Exists for testing purposes, not part of the ImageResource interface.
+   */
+  public int getHeight() {
+    return height;
+  }
+
+  /**
+   * Exists for testing purposes, not part of the ImageResource interface.
+   */
+  public int getLeft() {
+    return left;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  /**
+   * Exists for testing purposes, not part of the ImageResource interface.
+   */
+  public int getTop() {
+    return top;
+  }
+
+  /**
+   * Exists for testing purposes, not part of the ImageResource interface.
+   */
+  public String getURL() {
+    return url;
+  }
+
+  /**
+   * Exists for testing purposes, not part of the ImageResource interface.
+   */
+  public int getWidth() {
+    return width;
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/CssGenerationVisitor.java b/user/src/com/google/gwt/resources/css/CssGenerationVisitor.java
new file mode 100644
index 0000000..7fcfa95
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/CssGenerationVisitor.java
@@ -0,0 +1,296 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css;
+
+import com.google.gwt.dev.util.TextOutput;
+import com.google.gwt.resources.css.ast.Context;
+import com.google.gwt.resources.css.ast.CssDef;
+import com.google.gwt.resources.css.ast.CssEval;
+import com.google.gwt.resources.css.ast.CssIf;
+import com.google.gwt.resources.css.ast.CssMediaRule;
+import com.google.gwt.resources.css.ast.CssNoFlip;
+import com.google.gwt.resources.css.ast.CssNode;
+import com.google.gwt.resources.css.ast.CssPageRule;
+import com.google.gwt.resources.css.ast.CssProperty;
+import com.google.gwt.resources.css.ast.CssRule;
+import com.google.gwt.resources.css.ast.CssSelector;
+import com.google.gwt.resources.css.ast.CssSprite;
+import com.google.gwt.resources.css.ast.CssUrl;
+import com.google.gwt.resources.css.ast.CssVisitor;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/**
+ * Generates a static CSS template string and provides information on where to
+ * inject dynamic expressions.
+ */
+public class CssGenerationVisitor extends CssVisitor {
+  private final TextOutput out;
+
+  private boolean needsOpenBrace;
+
+  private boolean needsComma;
+  private final boolean substituteDots;
+  private final SortedMap<Integer, List<CssNode>> substitutionPositions = new TreeMap<Integer, List<CssNode>>();
+
+  /**
+   * Constructor.
+   * 
+   * @param out the output hondler
+   */
+  public CssGenerationVisitor(TextOutput out) {
+    this(out, false);
+  }
+
+  /**
+   * Constructor for producing an abbreviated form of the template for use with
+   * {@link CssNode#toString()}.
+   * 
+   * @param out the output handler
+   * @param substituteDots if <code>true</code> locations in the text output
+   *          where expression substitutions would normally occur are replaced
+   *          with a textual placeholder
+   */
+  public CssGenerationVisitor(TextOutput out, boolean substituteDots) {
+    this.out = out;
+    this.substituteDots = substituteDots;
+  }
+
+  @Override
+  public void endVisit(CssIf x, Context ctx) {
+    // Match up an explanatory comment
+    out.indentOut();
+    out.printOpt("/* } */");
+    out.newlineOpt();
+  }
+
+  @Override
+  public void endVisit(CssMediaRule x, Context ctx) {
+    out.indentOut();
+    out.print("}");
+    out.newline();
+  }
+
+  @Override
+  public void endVisit(CssNoFlip x, Context ctx) {
+    out.printOpt("/*} @noflip */");
+    out.newlineOpt();
+  }
+
+  @Override
+  public void endVisit(CssPageRule x, Context ctx) {
+    out.indentOut();
+    out.print("}");
+    out.newline();
+  }
+
+  @Override
+  public void endVisit(CssRule x, Context ctx) {
+    if (!x.getProperties().isEmpty()) {
+      // Don't print empty rule blocks
+      closeBrace();
+    }
+  }
+
+  public SortedMap<Integer, List<CssNode>> getSubstitutionPositions() {
+    return substitutionPositions;
+  }
+
+  @Override
+  public boolean visit(CssDef x, Context ctx) {
+    // These are not valid CSS
+    out.printOpt("/* CssDef */");
+    out.newlineOpt();
+    return false;
+  }
+
+  @Override
+  public boolean visit(CssEval x, Context ctx) {
+    // These are not valid CSS
+    out.printOpt("/* CssEval */");
+    out.newlineOpt();
+    return false;
+  }
+
+  @Override
+  public boolean visit(CssIf x, Context ctx) {
+    // Record where the contents of the if block should be inserted
+    StringBuilder expr = new StringBuilder("/* @if ");
+    if (x.getExpression() != null) {
+      expr.append(x.getExpression()).append(" ");
+    } else {
+      expr.append(x.getPropertyName()).append(" ");
+      for (String v : x.getPropertyValues()) {
+        expr.append(v).append(" ");
+      }
+    }
+    expr.append("{ */");
+    out.printOpt(expr.toString());
+    out.newlineOpt();
+    out.indentIn();
+    addSubstitition(x);
+    return false;
+  }
+
+  @Override
+  public boolean visit(CssMediaRule x, Context ctx) {
+    out.print("@MEDIA");
+    for (String m : x.getMedias()) {
+      out.print(" " + m);
+    }
+    spaceOpt();
+    out.print("{");
+    out.newlineOpt();
+    out.indentIn();
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssNoFlip x, Context ctx) {
+    out.printOpt("/*@noflip { */)");
+    out.newlineOpt();
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssPageRule x, Context ctx) {
+    out.print("@page");
+    if (x.getPseudoPage() != null) {
+      out.print(" :");
+      out.print(x.getPseudoPage());
+    }
+    spaceOpt();
+    out.print("{");
+    out.newlineOpt();
+    out.indentIn();
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssProperty x, Context ctx) {
+    if (needsOpenBrace) {
+      openBrace();
+      needsOpenBrace = false;
+    }
+
+    out.print(x.getName());
+    colon();
+    addSubstitition(x);
+
+    if (x.isImportant()) {
+      important();
+    }
+
+    semi();
+
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssRule x, Context ctx) {
+    if (x.getProperties().isEmpty()) {
+      // Don't print empty rule blocks
+      return false;
+    }
+
+    needsOpenBrace = true;
+    needsComma = false;
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssSelector x, Context ctx) {
+    if (needsComma) {
+      comma();
+    }
+    needsComma = true;
+    out.print(x.getSelector());
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssSprite x, Context ctx) {
+    // These are not valid CSS
+    out.printOpt("/* CssSprite */");
+    out.newlineOpt();
+    addSubstitition(x);
+    return false;
+  }
+
+  @Override
+  public boolean visit(CssUrl x, Context ctx) {
+    // These are not valid CSS
+    out.printOpt("/* CssUrl */");
+    out.newlineOpt();
+    return false;
+  }
+
+  private void addSubstitition(CssNode node) {
+    if (substituteDots) {
+      out.printOpt(".....");
+      out.newlineOpt();
+    } else {
+      int position = out.toString().length();
+      if (substitutionPositions.containsKey(position)) {
+        substitutionPositions.get(position).add(node);
+      } else {
+        List<CssNode> nodes = new ArrayList<CssNode>();
+        nodes.add(node);
+        substitutionPositions.put(position, nodes);
+      }
+    }
+  }
+
+  private void closeBrace() {
+    out.indentOut();
+    out.print('}');
+    out.newline();
+  }
+
+  private void colon() {
+    spaceOpt();
+    out.print(':');
+    spaceOpt();
+  }
+
+  private void comma() {
+    out.print(',');
+    spaceOpt();
+  }
+
+  private void important() {
+    out.print(" !important");
+  }
+
+  private void openBrace() {
+    spaceOpt();
+    out.print('{');
+    out.newlineOpt();
+    out.indentIn();
+  }
+
+  private void semi() {
+    out.print(';');
+    out.newlineOpt();
+  }
+
+  private void spaceOpt() {
+    out.printOpt(' ');
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/GenerateCssAst.java b/user/src/com/google/gwt/resources/css/GenerateCssAst.java
new file mode 100644
index 0000000..c1a9f8a
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/GenerateCssAst.java
@@ -0,0 +1,1006 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.resources.css.ast.CssDef;
+import com.google.gwt.resources.css.ast.CssEval;
+import com.google.gwt.resources.css.ast.CssIf;
+import com.google.gwt.resources.css.ast.CssMediaRule;
+import com.google.gwt.resources.css.ast.CssNoFlip;
+import com.google.gwt.resources.css.ast.CssNode;
+import com.google.gwt.resources.css.ast.CssPageRule;
+import com.google.gwt.resources.css.ast.CssProperty;
+import com.google.gwt.resources.css.ast.CssRule;
+import com.google.gwt.resources.css.ast.CssSelector;
+import com.google.gwt.resources.css.ast.CssSprite;
+import com.google.gwt.resources.css.ast.CssStylesheet;
+import com.google.gwt.resources.css.ast.CssUrl;
+import com.google.gwt.resources.css.ast.HasNodes;
+import com.google.gwt.resources.css.ast.HasProperties;
+import com.google.gwt.resources.css.ast.CssProperty.DotPathValue;
+import com.google.gwt.resources.css.ast.CssProperty.IdentValue;
+import com.google.gwt.resources.css.ast.CssProperty.ListValue;
+import com.google.gwt.resources.css.ast.CssProperty.NumberValue;
+import com.google.gwt.resources.css.ast.CssProperty.StringValue;
+import com.google.gwt.resources.css.ast.CssProperty.Value;
+
+import org.w3c.css.sac.AttributeCondition;
+import org.w3c.css.sac.CSSException;
+import org.w3c.css.sac.CSSParseException;
+import org.w3c.css.sac.CharacterDataSelector;
+import org.w3c.css.sac.CombinatorCondition;
+import org.w3c.css.sac.Condition;
+import org.w3c.css.sac.ConditionalSelector;
+import org.w3c.css.sac.ContentCondition;
+import org.w3c.css.sac.DescendantSelector;
+import org.w3c.css.sac.DocumentHandler;
+import org.w3c.css.sac.ElementSelector;
+import org.w3c.css.sac.ErrorHandler;
+import org.w3c.css.sac.InputSource;
+import org.w3c.css.sac.LangCondition;
+import org.w3c.css.sac.LexicalUnit;
+import org.w3c.css.sac.NegativeCondition;
+import org.w3c.css.sac.NegativeSelector;
+import org.w3c.css.sac.PositionalCondition;
+import org.w3c.css.sac.ProcessingInstructionSelector;
+import org.w3c.css.sac.SACMediaList;
+import org.w3c.css.sac.Selector;
+import org.w3c.css.sac.SelectorList;
+import org.w3c.css.sac.SiblingSelector;
+import org.w3c.flute.parser.Parser;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Stack;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Generates a CssStylesheet from the contents of a URL.
+ */
+public class GenerateCssAst {
+
+  /**
+   * Maps SAC CSSParseExceptions into a TreeLogger. All parsing errors will be
+   * recorded in a single TreeLogger branch, which will be created only if a
+   * loggable error message is emitted.
+   */
+  private static class Errors implements ErrorHandler {
+    /**
+     * A flag that controls whether or not the exec method will fail.
+     */
+    private boolean fatalErrorEncountered;
+    private TreeLogger logger;
+    private final TreeLogger parentLogger;
+
+    /**
+     * Constructor.
+     * 
+     * @param parentLogger the TreeLogger that should be branched to produce the
+     *          CSS parsing messages.
+     */
+    public Errors(TreeLogger parentLogger) {
+      this.parentLogger = parentLogger;
+    }
+
+    public void error(CSSParseException exception) throws CSSException {
+      // TODO Since this indicates a loss of data, should this be a fatal error?
+      log(TreeLogger.WARN, exception);
+    }
+
+    public void fatalError(CSSParseException exception) throws CSSException {
+      log(TreeLogger.ERROR, exception);
+    }
+
+    public void log(TreeLogger.Type type, String message) {
+      log(type, message, null);
+    }
+
+    public void log(TreeLogger.Type type, String message, Throwable t) {
+      fatalErrorEncountered |= type == TreeLogger.Type.ERROR;
+      if (parentLogger.isLoggable(type)) {
+        maybeBranch();
+        logger.log(type, message, t);
+      }
+    }
+
+    public void warning(CSSParseException exception) throws CSSException {
+      log(TreeLogger.DEBUG, exception);
+    }
+
+    private void log(TreeLogger.Type type, CSSParseException e) {
+      log(type, "Line " + e.getLineNumber() + " column " + e.getColumnNumber()
+          + ": " + e.getMessage());
+    }
+
+    private void maybeBranch() {
+      if (logger == null) {
+        logger = parentLogger.branch(TreeLogger.INFO,
+            "The following problems were detected");
+      }
+    }
+  }
+
+  /**
+   * Maps the SAC model into our own CSS AST nodes.
+   */
+  private static class GenerationHandler implements DocumentHandler {
+    /**
+     * The stylesheet that is being composed.
+     */
+    private final CssStylesheet css = new CssStylesheet();
+
+    /**
+     * Accumulates CSS nodes as they are created.
+     */
+    private final Stack<HasNodes> currentParent = new Stack<HasNodes>();
+
+    /**
+     * Accumulates CSS properties as they are seen.
+     */
+    private HasProperties currentRule;
+
+    /**
+     * Records references to {@code @def} rules.
+     */
+    private final Map<String, CssDef> defs = new HashMap<String, CssDef>();
+
+    /**
+     * Used when parsing the contents of meta-styles.
+     */
+    private final Errors errors;
+
+    /**
+     * Used by {@link #startSelector(SelectorList)} to suppress the creation of
+     * new CssRules in favor of retaining {@link #currentRule}.
+     */
+    private boolean nextSelectorCreatesRule = true;
+
+    public GenerationHandler(Errors errors) {
+      this.errors = errors;
+      currentParent.push(css);
+    }
+
+    public void comment(String text) throws CSSException {
+      // Ignore comments
+      // TODO Should comments be retained but not generally printed?
+    }
+
+    public void endDocument(InputSource source) throws CSSException {
+    }
+
+    public void endFontFace() throws CSSException {
+    }
+
+    public void endMedia(SACMediaList media) throws CSSException {
+      currentParent.pop();
+    }
+
+    public void endPage(String name, String pseudoPage) throws CSSException {
+    }
+
+    public void endSelector(SelectorList selectors) throws CSSException {
+    }
+
+    /**
+     * Reflectively invoke a method named parseRule on this instance.
+     */
+    public void ignorableAtRule(String atRule) throws CSSException {
+      String ruleName = atRule.substring(1, atRule.indexOf(" "));
+      String methodName = "parse" + (Character.toUpperCase(ruleName.charAt(0)))
+          + ruleName.substring(1);
+      try {
+        Method parseMethod = getClass().getDeclaredMethod(methodName,
+            String.class);
+        parseMethod.invoke(this, atRule);
+      } catch (NoSuchMethodException e) {
+        errors.log(TreeLogger.WARN, "Ignoring @" + ruleName);
+      } catch (IllegalAccessException e) {
+        errors.log(TreeLogger.ERROR, "Unable to invoke parse method ", e);
+      } catch (InvocationTargetException e) {
+        if (e.getCause() instanceof CSSException) {
+          throw (CSSException) e.getCause();
+        }
+
+        errors.log(TreeLogger.ERROR, "Unable to invoke parse method ", e);
+      }
+    }
+
+    public void importStyle(String uri, SACMediaList media,
+        String defaultNamespaceURI) throws CSSException {
+    }
+
+    public void namespaceDeclaration(String prefix, String uri)
+        throws CSSException {
+    }
+
+    public void property(String name, LexicalUnit value, boolean important)
+        throws CSSException {
+      List<Value> values = new ArrayList<Value>();
+      if (value != null) {
+        extractValueOf(values, value);
+      }
+      currentRule.getProperties().add(
+          new CssProperty(escapeIdent(name), new ListValue(values), important));
+    }
+
+    public void startDocument(InputSource source) throws CSSException {
+    }
+
+    public void startFontFace() throws CSSException {
+    }
+
+    public void startMedia(SACMediaList media) throws CSSException {
+      CssMediaRule r = new CssMediaRule();
+      for (int i = 0; i < media.getLength(); i++) {
+        r.getMedias().add(media.item(i));
+      }
+
+      pushParent(r);
+    }
+
+    public void startPage(String name, String pseudoPage) throws CSSException {
+      CssPageRule r = new CssPageRule();
+      // name appears to be unused in CSS2
+      r.setPseudoPage(pseudoPage);
+      addNode(r);
+      currentRule = r;
+    }
+
+    public void startSelector(SelectorList selectors) throws CSSException {
+      CssRule r;
+
+      if (nextSelectorCreatesRule) {
+        r = new CssRule();
+        addNode(r);
+        currentRule = r;
+      } else {
+        r = (CssRule) currentRule;
+        nextSelectorCreatesRule = true;
+      }
+
+      for (int i = 0; i < selectors.getLength(); i++) {
+        r.getSelectors().add(new CssSelector(valueOf(selectors.item(i))));
+      }
+    }
+
+    void parseDef(String atRule) {
+      String value = atRule.substring(4, atRule.length()).trim();
+
+      InputSource s = new InputSource();
+      s.setCharacterStream(new StringReader(value));
+      Parser parser = new Parser();
+      parser.setErrorHandler(errors);
+
+      final List<Value> values = new ArrayList<Value>();
+      parser.setDocumentHandler(new PropertyExtractor(values));
+
+      try {
+        String dummy = "* { prop : " + value + "}";
+        parser.parseStyleSheet(new InputSource(new StringReader(dummy)));
+      } catch (IOException e) {
+        assert false : "Should never happen";
+      }
+
+      if (values.size() < 2) {
+        throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+            "@def rules must specify an identifier and one or more values",
+            null);
+      }
+
+      IdentValue defName = values.get(0).isIdentValue();
+
+      if (defName == null) {
+        throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+            "First lexical unit must be an identifier", null);
+      }
+
+      /*
+       * Replace any references to previously-seen @def constructs. We do
+       * expansion up-front to prevent the need for cycle-detection later.
+       */
+      for (ListIterator<Value> it = values.listIterator(1); it.hasNext();) {
+        IdentValue maybeDefReference = it.next().isIdentValue();
+        if (maybeDefReference != null) {
+          CssDef previousDef = defs.get(maybeDefReference.getIdent());
+          if (previousDef != null) {
+            it.remove();
+            for (Value previousValue : previousDef.getValues()) {
+              it.add(previousValue);
+            }
+          }
+        }
+      }
+
+      CssDef def = new CssDef(defName.getIdent());
+      def.getValues().addAll(values.subList(1, values.size()));
+      addNode(def);
+
+      defs.put(defName.getIdent(), def);
+    }
+
+    /**
+     * The elif nodes are processed as though they were {@code @if} nodes. The
+     * newly-generated CssIf node will be attached to the last CssIf in the
+     * if/else chain.
+     */
+    void parseElif(String atRule) throws CSSException {
+      List<CssNode> nodes = currentParent.peek().getNodes();
+      CssIf lastIf = findLastIfInChain(nodes);
+
+      if (lastIf == null) {
+        throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+            "@elif must immediately follow an @if or @elif", null);
+      }
+
+      assert lastIf.getElseNodes().isEmpty();
+
+      // @elif -> lif (because parseIf strips the first three chars)
+      parseIf(atRule.substring(2));
+
+      // Fix up the structure by remove the newly-created node from the parent
+      // context and moving it to the end of the @if chain
+      lastIf.getElseNodes().add(nodes.remove(nodes.size() - 1));
+    }
+
+    /**
+     * The else nodes are processed as though they were written as {@code @elif
+     * true} rules.
+     */
+    void parseElse(String atRule) throws CSSException {
+      // The last CssIf in the if/else chain
+      CssIf lastIf = findLastIfInChain(currentParent.peek().getNodes());
+
+      if (lastIf == null) {
+        throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+            "@else must immediately follow an @if or @elif", null);
+      }
+
+      // Create the CssIf to hold the @else rules
+      String fakeElif = "@elif (true) " + atRule.substring(atRule.indexOf("{"));
+      parseElif(fakeElif);
+      CssIf elseIf = findLastIfInChain(currentParent.peek().getNodes());
+
+      assert lastIf.getElseNodes().size() == 1
+          && lastIf.getElseNodes().get(0) == elseIf;
+      assert elseIf.getElseNodes().isEmpty();
+
+      // Merge the rules into the last CssIf to break the chain and prevent
+      // @else followed by @else
+      lastIf.getElseNodes().clear();
+      lastIf.getElseNodes().addAll(elseIf.getNodes());
+    }
+
+    void parseEval(String atRule) throws CSSException {
+      // @eval key com.google.Type.staticFunction
+      String[] parts = atRule.substring(0, atRule.length() - 1).split("\\s");
+
+      if (parts.length != 3) {
+        throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+            "Incorrect number of parts for @eval", null);
+      }
+
+      CssEval eval = new CssEval(parts[1], parts[2]);
+      addNode(eval);
+    }
+
+    void parseIf(String atRule) throws CSSException {
+      String predicate = atRule.substring(3, atRule.indexOf('{') - 1).trim();
+      String blockContents = atRule.substring(atRule.indexOf('{') + 1,
+          atRule.length() - 1);
+
+      CssIf cssIf = new CssIf();
+
+      if (predicate.startsWith("(") && predicate.endsWith(")")) {
+        cssIf.setExpression(predicate);
+      } else {
+
+        String[] predicateParts = predicate.split("\\s");
+
+        switch (predicateParts.length) {
+          case 0:
+            throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+                "Incorrect format for @if predicate", null);
+          case 1:
+            if (predicateParts[0].length() == 0) {
+              throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+                  "Incorrect format for @if predicate", null);
+            }
+            errors.log(
+                TreeLogger.WARN,
+                "Deprecated syntax for Java expression detected. Enclose the expression in parentheses");
+            cssIf.setExpression(predicateParts[0]);
+            break;
+          default:
+            if (predicateParts[0].startsWith("!")) {
+              cssIf.setNegated(true);
+              cssIf.setProperty(predicateParts[0].substring(1));
+            } else {
+              cssIf.setProperty(predicateParts[0]);
+            }
+            String[] values = new String[predicateParts.length - 1];
+            System.arraycopy(predicateParts, 1, values, 0, values.length);
+            cssIf.setPropertyValues(values);
+        }
+      }
+
+      parseInnerStylesheet("@if", cssIf, blockContents);
+    }
+
+    void parseNoflip(String atRule) throws CSSException {
+      String blockContents = atRule.substring(atRule.indexOf('{') + 1,
+          atRule.length() - 1);
+
+      parseInnerStylesheet("@noflip", new CssNoFlip(), blockContents);
+    }
+
+    void parseSprite(String atRule) throws CSSException {
+      CssSprite sprite = new CssSprite();
+      currentRule = sprite;
+      addNode(sprite);
+
+      // Flag to tell startSelector() to use the CssSprite instead of creating
+      // its own CssRule.
+      nextSelectorCreatesRule = false;
+
+      // parse the inner text
+      InputSource s = new InputSource();
+      s.setCharacterStream(new StringReader(atRule.substring(7)));
+      Parser parser = new Parser();
+      parser.setDocumentHandler(this);
+      parser.setErrorHandler(errors);
+
+      try {
+        parser.parseRule(s);
+      } catch (IOException e) {
+        throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+            "Unable to parse @sprite", e);
+      }
+    }
+
+    void parseUrl(String atRule) throws CSSException {
+      // @url key dataResourceFunction
+      String[] parts = atRule.substring(0, atRule.length() - 1).split("\\s");
+
+      if (parts.length != 3) {
+        throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+            "Incorrect number of parts for @url", null);
+      }
+
+      CssUrl url = new CssUrl(parts[1], parts[2]);
+      addNode(url);
+    }
+
+    /**
+     * Add a node to the current parent.
+     */
+    private void addNode(CssNode node) {
+      currentParent.peek().getNodes().add(node);
+    }
+
+    private <T extends CssNode & HasNodes> void parseInnerStylesheet(
+        String tagName, T parent, String blockContents) {
+      pushParent(parent);
+
+      // parse the inner text
+      InputSource s = new InputSource();
+      s.setCharacterStream(new StringReader(blockContents));
+      Parser parser = new Parser();
+      parser.setDocumentHandler(this);
+      parser.setErrorHandler(errors);
+
+      try {
+        parser.parseStyleSheet(s);
+      } catch (IOException e) {
+        throw new CSSException(CSSException.SAC_SYNTAX_ERR, "Unable to parse "
+            + tagName, e);
+      }
+
+      if (currentParent.pop() != parent) {
+        // This is a coding error
+        throw new RuntimeException("Incorrect element popped");
+      }
+    }
+
+    /**
+     * Adds a node to the current parent and then makes the node the current
+     * parent node.
+     */
+    private <T extends CssNode & HasNodes> void pushParent(T newParent) {
+      addNode(newParent);
+      currentParent.push(newParent);
+    }
+  }
+
+  /**
+   * Extracts all properties in a document into a List.
+   */
+  private static class PropertyExtractor implements DocumentHandler {
+    private final List<Value> values;
+
+    private PropertyExtractor(List<Value> values) {
+      this.values = values;
+    }
+
+    public void comment(String text) throws CSSException {
+    }
+
+    public void endDocument(InputSource source) throws CSSException {
+    }
+
+    public void endFontFace() throws CSSException {
+    }
+
+    public void endMedia(SACMediaList media) throws CSSException {
+    }
+
+    public void endPage(String name, String pseudoPage) throws CSSException {
+    }
+
+    public void endSelector(SelectorList selectors) throws CSSException {
+    }
+
+    public void ignorableAtRule(String atRule) throws CSSException {
+    }
+
+    public void importStyle(String uri, SACMediaList media,
+        String defaultNamespaceURI) throws CSSException {
+    }
+
+    public void namespaceDeclaration(String prefix, String uri)
+        throws CSSException {
+    }
+
+    public void property(String name, LexicalUnit value, boolean important)
+        throws CSSException {
+      extractValueOf(values, value);
+    }
+
+    public void startDocument(InputSource source) throws CSSException {
+    }
+
+    public void startFontFace() throws CSSException {
+    }
+
+    public void startMedia(SACMediaList media) throws CSSException {
+    }
+
+    public void startPage(String name, String pseudoPage) throws CSSException {
+    }
+
+    public void startSelector(SelectorList selectors) throws CSSException {
+    }
+  }
+
+  private static final String LITERAL_FUNCTION_NAME = "literal";
+
+  private static final String VALUE_FUNCTION_NAME = "value";
+
+  /**
+   * Create a CssStylesheet from the contents of a URL.
+   */
+  public static CssStylesheet exec(TreeLogger logger, URL[] stylesheets)
+      throws UnableToCompleteException {
+    Parser p = new Parser();
+    Errors errors = new Errors(logger);
+    GenerationHandler g = new GenerationHandler(errors);
+    p.setDocumentHandler(g);
+    p.setErrorHandler(errors);
+
+    for (URL stylesheet : stylesheets) {
+      TreeLogger branchLogger = logger.branch(TreeLogger.DEBUG,
+          "Parsing CSS stylesheet " + stylesheet.toExternalForm());
+      try {
+        p.parseStyleSheet(stylesheet.toURI().toString());
+        continue;
+      } catch (CSSException e) {
+        branchLogger.log(TreeLogger.ERROR, "Unable to parse CSS", e);
+      } catch (IOException e) {
+        branchLogger.log(TreeLogger.ERROR, "Unable to parse CSS", e);
+      } catch (URISyntaxException e) {
+        branchLogger.log(TreeLogger.ERROR, "Unable to parse CSS", e);
+      }
+      throw new UnableToCompleteException();
+    }
+
+    if (errors.fatalErrorEncountered) {
+      // Logging will have been performed by the Errors instance, just exit
+      throw new UnableToCompleteException();
+    }
+
+    return g.css;
+  }
+
+  /**
+   * Expresses an rgb function as a hex expression.
+   * 
+   * @param colors a sequence of LexicalUnits, assumed to be
+   *          <code>(INT COMMA INT COMMA INT)</code>
+   * @return the minimal hex expression for the RGB color values
+   */
+  private static Value colorValue(LexicalUnit colors) {
+    LexicalUnit red = colors;
+    assert red.getLexicalUnitType() == LexicalUnit.SAC_INTEGER;
+    LexicalUnit green = red.getNextLexicalUnit().getNextLexicalUnit();
+    assert green.getLexicalUnitType() == LexicalUnit.SAC_INTEGER;
+    LexicalUnit blue = green.getNextLexicalUnit().getNextLexicalUnit();
+    assert blue.getLexicalUnitType() == LexicalUnit.SAC_INTEGER;
+
+    int r = Math.min(red.getIntegerValue(), 255);
+    int g = Math.min(green.getIntegerValue(), 255);
+    int b = Math.min(blue.getIntegerValue(), 255);
+
+    String sr = Integer.toHexString(r);
+    if (sr.length() == 1) {
+      sr = "0" + sr;
+    }
+
+    String sg = Integer.toHexString(g);
+    if (sg.length() == 1) {
+      sg = "0" + sg;
+    }
+
+    String sb = Integer.toHexString(b);
+    if (sb.length() == 1) {
+      sb = "0" + sb;
+    }
+
+    // #AABBCC --> #ABC
+    if (sr.charAt(0) == sr.charAt(1) && sg.charAt(0) == sg.charAt(1)
+        && sb.charAt(0) == sb.charAt(1)) {
+      sr = sr.substring(1);
+      sg = sg.substring(1);
+      sb = sb.substring(1);
+    }
+
+    return new IdentValue("#" + sr + sg + sb);
+  }
+
+  private static String escapeIdent(String selector) {
+    assert selector.length() > 0;
+
+    StringBuilder toReturn = new StringBuilder();
+    if (!isIdentStart(selector.charAt(0))) {
+      toReturn.append('\\');
+    }
+    toReturn.append(selector.charAt(0));
+
+    if (selector.length() > 1) {
+      for (char c : selector.substring(1).toCharArray()) {
+        if (!isIdentPart(c)) {
+          toReturn.append('\\');
+        }
+        toReturn.append(c);
+      }
+    }
+    return toReturn.toString();
+  }
+
+  /**
+   * Convert a LexicalUnit list into a List of Values.
+   */
+  private static void extractValueOf(List<Value> accumulator, LexicalUnit value) {
+    do {
+      accumulator.add(valueOf(value));
+      value = value.getNextLexicalUnit();
+    } while (value != null);
+  }
+
+  /**
+   * The elif and else constructs are modeled as nested if statements in the
+   * CssIf's elseNodes field. This method will search a list of CssNodes and
+   * remove the last chained CssIf from the last element in the list of nodes.
+   */
+  private static CssIf findLastIfInChain(List<CssNode> nodes) {
+    if (nodes.isEmpty()) {
+      return null;
+    }
+
+    CssNode lastNode = nodes.get(nodes.size() - 1);
+    if (lastNode instanceof CssIf) {
+      CssIf asIf = (CssIf) lastNode;
+      if (asIf.getElseNodes().isEmpty()) {
+        return asIf;
+      } else {
+        return findLastIfInChain(asIf.getElseNodes());
+      }
+    }
+    return null;
+  }
+
+  private static boolean isIdentPart(char c) {
+    return Character.isLetterOrDigit(c) || (c == '\\') || (c == '-');
+  }
+
+  private static boolean isIdentStart(char c) {
+    return Character.isLetter(c) || (c == '\\');
+  }
+
+  /**
+   * Utility method to concatenate strings.
+   */
+  private static String join(Iterable<Value> elements, String separator) {
+    StringBuilder b = new StringBuilder();
+    for (Iterator<Value> i = elements.iterator(); i.hasNext();) {
+      b.append(i.next().toCss());
+      if (i.hasNext()) {
+        b.append(separator);
+      }
+    }
+    return b.toString();
+  }
+
+  private static String maybeUnquote(String s) {
+    if (s.startsWith("\"") && s.endsWith("\"")) {
+      return s.substring(1, s.length() - 1);
+    }
+    return s;
+  }
+
+  /**
+   * Used when evaluating literal() rules.
+   */
+  private static String unescapeLiteral(String s) {
+    s = s.replaceAll(Pattern.quote("\\\""), "\"");
+    s = s.replaceAll(Pattern.quote("\\\\"), Matcher.quoteReplacement("\\"));
+    return s;
+  }
+
+  private static String valueOf(Condition condition) {
+    if (condition instanceof AttributeCondition) {
+      AttributeCondition c = (AttributeCondition) condition;
+      switch (c.getConditionType()) {
+        case Condition.SAC_ATTRIBUTE_CONDITION:
+          return "[" + c.getLocalName()
+              + (c.getValue() != null ? "=\"" + c.getValue() + '"' : "") + "]";
+        case Condition.SAC_ONE_OF_ATTRIBUTE_CONDITION:
+          return "[" + c.getLocalName() + "~=\"" + c.getValue() + "\"]";
+        case Condition.SAC_BEGIN_HYPHEN_ATTRIBUTE_CONDITION:
+          return "[" + c.getLocalName() + "|=\"" + c.getValue() + "\"]";
+        case Condition.SAC_ID_CONDITION:
+          return "#" + c.getValue();
+        case Condition.SAC_CLASS_CONDITION:
+          return "." + c.getValue();
+        case Condition.SAC_PSEUDO_CLASS_CONDITION:
+          return ":" + c.getValue();
+      }
+
+    } else if (condition instanceof CombinatorCondition) {
+      CombinatorCondition c = (CombinatorCondition) condition;
+      switch (condition.getConditionType()) {
+        case Condition.SAC_AND_CONDITION:
+          return valueOf(c.getFirstCondition())
+              + valueOf(c.getSecondCondition());
+        case Condition.SAC_OR_CONDITION:
+          // Unimplemented in CSS2?
+      }
+
+    } else if (condition instanceof ContentCondition) {
+      // Unimplemented in CSS2?
+
+    } else if (condition instanceof LangCondition) {
+      LangCondition c = (LangCondition) condition;
+      return ":lang(" + c.getLang() + ")";
+
+    } else if (condition instanceof NegativeCondition) {
+      // Unimplemented in CSS2?
+    } else if (condition instanceof PositionalCondition) {
+      // Unimplemented in CSS2?
+    }
+
+    throw new RuntimeException("Unhandled condition of type "
+        + condition.getConditionType() + " " + condition.getClass().getName());
+  }
+
+  private static Value valueOf(LexicalUnit value) {
+    switch (value.getLexicalUnitType()) {
+      case LexicalUnit.SAC_ATTR:
+        return new IdentValue("attr(" + value.getStringValue() + ")");
+      case LexicalUnit.SAC_IDENT:
+        return new IdentValue(escapeIdent(value.getStringValue()));
+      case LexicalUnit.SAC_STRING_VALUE:
+        return new StringValue(value.getStringValue());
+      case LexicalUnit.SAC_RGBCOLOR:
+        // flute models the commas as operators so no separator needed
+        return colorValue(value.getParameters());
+      case LexicalUnit.SAC_INTEGER:
+        return new NumberValue(value.getIntegerValue());
+      case LexicalUnit.SAC_REAL:
+        return new NumberValue(value.getFloatValue());
+      case LexicalUnit.SAC_CENTIMETER:
+      case LexicalUnit.SAC_DEGREE:
+      case LexicalUnit.SAC_DIMENSION:
+      case LexicalUnit.SAC_EM:
+      case LexicalUnit.SAC_EX:
+      case LexicalUnit.SAC_GRADIAN:
+      case LexicalUnit.SAC_HERTZ:
+      case LexicalUnit.SAC_KILOHERTZ:
+      case LexicalUnit.SAC_MILLIMETER:
+      case LexicalUnit.SAC_MILLISECOND:
+      case LexicalUnit.SAC_PERCENTAGE:
+      case LexicalUnit.SAC_PICA:
+      case LexicalUnit.SAC_PIXEL:
+      case LexicalUnit.SAC_POINT:
+      case LexicalUnit.SAC_RADIAN:
+      case LexicalUnit.SAC_SECOND:
+        return new NumberValue(value.getFloatValue(),
+            value.getDimensionUnitText());
+      case LexicalUnit.SAC_URI:
+        return new IdentValue("url(" + value.getStringValue() + ")");
+      case LexicalUnit.SAC_OPERATOR_COMMA:
+        return new IdentValue(",");
+      case LexicalUnit.SAC_COUNTER_FUNCTION:
+      case LexicalUnit.SAC_COUNTERS_FUNCTION:
+      case LexicalUnit.SAC_FUNCTION: {
+        if (value.getFunctionName().equals(VALUE_FUNCTION_NAME)) {
+          // This is a call to value()
+          List<Value> params = new ArrayList<Value>();
+          extractValueOf(params, value.getParameters());
+
+          if (params.size() != 1 && params.size() != 3) {
+            throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+                "Incorrect number of parameters to " + VALUE_FUNCTION_NAME,
+                null);
+          }
+
+          Value dotPathValue = params.get(0);
+          String dotPath = maybeUnquote(((StringValue) dotPathValue).getValue());
+          String suffix = params.size() == 3
+              ? maybeUnquote(((StringValue) params.get(2)).getValue()) : "";
+
+          return new DotPathValue(dotPath, suffix);
+        } else if (value.getFunctionName().equals(LITERAL_FUNCTION_NAME)) {
+          // This is a call to value()
+          List<Value> params = new ArrayList<Value>();
+          extractValueOf(params, value.getParameters());
+
+          if (params.size() != 1) {
+            throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+                "Incorrect number of parameters to " + LITERAL_FUNCTION_NAME,
+                null);
+          }
+
+          Value expression = params.get(0);
+          if (!(expression instanceof StringValue)) {
+            throw new CSSException(CSSException.SAC_SYNTAX_ERR,
+                "The single argument to " + LITERAL_FUNCTION_NAME
+                    + " must be a string value", null);
+          }
+
+          String s = maybeUnquote(((StringValue) expression).getValue());
+          s = unescapeLiteral(s);
+
+          return new IdentValue(s);
+
+        } else {
+          // Just return a String representation of the original value
+          List<Value> parameters = new ArrayList<Value>();
+          extractValueOf(parameters, value.getParameters());
+          return new IdentValue(value.getFunctionName() + "("
+              + join(parameters, "") + ")");
+        }
+      }
+      case LexicalUnit.SAC_INHERIT:
+        return new IdentValue("inherit");
+      case LexicalUnit.SAC_OPERATOR_EXP:
+        return new IdentValue("^");
+      case LexicalUnit.SAC_OPERATOR_GE:
+        return new IdentValue(">=");
+      case LexicalUnit.SAC_OPERATOR_GT:
+        return new IdentValue(">");
+      case LexicalUnit.SAC_OPERATOR_LE:
+        return new IdentValue("<=");
+      case LexicalUnit.SAC_OPERATOR_LT:
+        return new IdentValue("<");
+      case LexicalUnit.SAC_OPERATOR_MINUS:
+        return new IdentValue("-");
+      case LexicalUnit.SAC_OPERATOR_MOD:
+        return new IdentValue("%");
+      case LexicalUnit.SAC_OPERATOR_MULTIPLY:
+        return new IdentValue("*");
+      case LexicalUnit.SAC_OPERATOR_PLUS:
+        return new IdentValue("+");
+      case LexicalUnit.SAC_OPERATOR_SLASH:
+        return new IdentValue("/");
+      case LexicalUnit.SAC_OPERATOR_TILDE:
+        return new IdentValue("~");
+      case LexicalUnit.SAC_RECT_FUNCTION: {
+        // Just return this as a String
+        List<Value> parameters = new ArrayList<Value>();
+        extractValueOf(parameters, value.getParameters());
+        return new IdentValue("rect(" + join(parameters, "") + ")");
+      }
+      case LexicalUnit.SAC_SUB_EXPRESSION:
+        // Should have been taken care of by our own traversal
+      case LexicalUnit.SAC_UNICODERANGE:
+        // Cannot be expressed in CSS2
+    }
+    throw new RuntimeException("Unhandled LexicalUnit type "
+        + value.getLexicalUnitType());
+  }
+
+  private static String valueOf(Selector selector) {
+    if (selector instanceof CharacterDataSelector) {
+      // Unimplemented in CSS2?
+
+    } else if (selector instanceof ConditionalSelector) {
+      ConditionalSelector s = (ConditionalSelector) selector;
+      String simpleSelector = valueOf(s.getSimpleSelector());
+
+      if ("*".equals(simpleSelector)) {
+        // Don't need the extra * for compound selectors
+        return valueOf(s.getCondition());
+      } else {
+        return simpleSelector + valueOf(s.getCondition());
+      }
+
+    } else if (selector instanceof DescendantSelector) {
+      DescendantSelector s = (DescendantSelector) selector;
+      switch (s.getSelectorType()) {
+        case Selector.SAC_CHILD_SELECTOR:
+          if (s.getSimpleSelector().getSelectorType() == Selector.SAC_PSEUDO_ELEMENT_SELECTOR) {
+            return valueOf(s.getAncestorSelector()) + ":"
+                + valueOf(s.getSimpleSelector());
+          } else {
+            return valueOf(s.getAncestorSelector()) + ">"
+                + valueOf(s.getSimpleSelector());
+          }
+        case Selector.SAC_DESCENDANT_SELECTOR:
+          return valueOf(s.getAncestorSelector()) + " "
+              + valueOf(s.getSimpleSelector());
+      }
+
+    } else if (selector instanceof ElementSelector) {
+      ElementSelector s = (ElementSelector) selector;
+      if (s.getLocalName() == null) {
+        return "*";
+      } else {
+        return escapeIdent(s.getLocalName());
+      }
+
+    } else if (selector instanceof NegativeSelector) {
+      // Unimplemented in CSS2?
+
+    } else if (selector instanceof ProcessingInstructionSelector) {
+      // Unimplemented in CSS2?
+
+    } else if (selector instanceof SiblingSelector) {
+      SiblingSelector s = (SiblingSelector) selector;
+      return valueOf(s.getSelector()) + "+" + valueOf(s.getSiblingSelector());
+    }
+
+    throw new RuntimeException("Unhandled selector of type "
+        + selector.getClass().getName());
+  }
+
+  /**
+   * Utility class.
+   */
+  private GenerateCssAst() {
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/Minify.java b/user/src/com/google/gwt/resources/css/Minify.java
new file mode 100644
index 0000000..1a75c5b
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/Minify.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.util.DefaultTextOutput;
+import com.google.gwt.dev.util.TextOutput;
+import com.google.gwt.dev.util.log.PrintWriterTreeLogger;
+import com.google.gwt.resources.css.ast.CssStylesheet;
+import com.google.gwt.util.tools.ArgHandlerExtra;
+import com.google.gwt.util.tools.ArgHandlerFlag;
+import com.google.gwt.util.tools.ToolBase;
+
+import java.io.File;
+import java.io.PrintWriter;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/**
+ * This is a command-line utility to minify a GWT CSS stylesheet.
+ */
+public class Minify extends ToolBase {
+
+  /**
+   * See {@link #printHelp()} for usage.
+   */
+  public static void main(String[] args) {
+    (new Minify()).exec(args);
+  }
+
+  private final PrintWriterTreeLogger logger = new PrintWriterTreeLogger(
+      new PrintWriter(System.err));
+  private URL source;
+  private boolean pretty;
+
+  private Minify() {
+    logger.setMaxDetail(TreeLogger.DEBUG);
+  }
+
+  @Override
+  protected String getDescription() {
+    return "Minify a CSS file";
+  }
+
+  private void exec(String[] args) {
+    registerHandler(new ArgHandlerExtra() {
+
+      @Override
+      public boolean addExtraArg(String arg) {
+        if (source != null) {
+          return false;
+        }
+
+        try {
+          source = (new File(arg)).toURL();
+          return true;
+        } catch (MalformedURLException e) {
+          e.printStackTrace();
+          return false;
+        }
+      }
+
+      @Override
+      public String getPurpose() {
+        return "The css file to process";
+      }
+
+      @Override
+      public String[] getTagArgs() {
+        return new String[] {"stylesheet.css"};
+      }
+    });
+
+    registerHandler(new ArgHandlerFlag() {
+      @Override
+      public String getPurpose() {
+        return "Enable human-parsable output";
+      }
+
+      @Override
+      public String getTag() {
+        return "-pretty";
+      }
+
+      @Override
+      public boolean setFlag() {
+        return pretty = true;
+      }
+    });
+
+    if (!processArgs(args)) {
+      System.exit(-1);
+    }
+
+    if (source == null) {
+      printHelp();
+      System.exit(-1);
+    }
+
+    try {
+      CssStylesheet sheet = GenerateCssAst.exec(logger, new URL[] {source});
+      TextOutput out = new DefaultTextOutput(!pretty);
+      (new CssGenerationVisitor(out)).accept(sheet);
+      System.out.println(out.toString());
+    } catch (UnableToCompleteException e) {
+      logger.log(TreeLogger.ERROR, "Unable to compile CSS");
+    }
+
+    System.exit(0);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CollapsedNode.java b/user/src/com/google/gwt/resources/css/ast/CollapsedNode.java
new file mode 100644
index 0000000..f3dae4d
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CollapsedNode.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.List;
+
+/**
+ * This delegate class bypasses traversal of a node, instead traversing the
+ * node's children. Any modifications made to the node list of the CollapsedNode
+ * will be reflected in the original node.
+ */
+public class CollapsedNode extends CssNode implements HasNodes {
+
+  private final List<CssNode> nodes;
+
+  public CollapsedNode(HasNodes parent) {
+    this(parent.getNodes());
+  }
+
+  public CollapsedNode(List<CssNode> nodes) {
+    this.nodes = nodes;
+  }
+
+  public List<CssNode> getNodes() {
+    return nodes;
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    visitor.acceptWithInsertRemove(getNodes());
+  }
+}
\ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/css/ast/Context.java b/user/src/com/google/gwt/resources/css/ast/Context.java
new file mode 100644
index 0000000..9ee2608
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/Context.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+/**
+ * The context in which a CSSNode visitation occurs. This represents the set of
+ * possible operations a CSSVisitor subclass can perform on the currently
+ * visited node.
+ */
+public interface Context {
+  boolean canInsert();
+
+  boolean canRemove();
+
+  void insertAfter(CssNode node);
+
+  void insertBefore(CssNode node);
+
+  void removeMe();
+
+  void replaceMe(CssNode node);
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssCompilerException.java b/user/src/com/google/gwt/resources/css/ast/CssCompilerException.java
new file mode 100644
index 0000000..044d306
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssCompilerException.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+/**
+ * Used by {@link CssVisitor}.
+ */
+public class CssCompilerException extends RuntimeException {
+  public CssCompilerException(String message) {
+    super(message);
+  }
+  
+  public CssCompilerException(String message, Throwable cause) {
+    super(message, cause);
+  }
+  
+  void addNode(CssNode node) {
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssDef.java b/user/src/com/google/gwt/resources/css/ast/CssDef.java
new file mode 100644
index 0000000..2506989
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssDef.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import com.google.gwt.resources.css.ast.CssProperty.Value;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A constant definition.
+ */
+public class CssDef extends CssNode {
+  private final String key;
+  private final List<Value> values = new ArrayList<Value>();
+
+  public CssDef(String key) {
+    this.key = key;
+  }
+
+  public String getKey() {
+    return key;
+  }
+
+  public List<Value> getValues() {
+    return values;
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    visitor.visit(this, context);
+    visitor.endVisit(this, context);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssEval.java b/user/src/com/google/gwt/resources/css/ast/CssEval.java
new file mode 100644
index 0000000..8a5ff98
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssEval.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import com.google.gwt.resources.css.ast.CssProperty.ExpressionValue;
+import com.google.gwt.resources.css.ast.CssProperty.Value;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A definition that is evaluated at runtime.
+ */
+public class CssEval extends CssDef {
+  private final List<Value> values;
+
+  public CssEval(String key, String expression) {
+    super(key);
+    Value value = new ExpressionValue(expression);
+    values = Collections.singletonList(value);
+  }
+
+  @Override
+  public List<Value> getValues() {
+    return values;
+  }
+
+  @Override
+  public void traverse(CssVisitor visitor, Context context) {
+    visitor.visit(this, context);
+    visitor.endVisit(this, context);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssIf.java b/user/src/com/google/gwt/resources/css/ast/CssIf.java
new file mode 100644
index 0000000..7a535f7
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssIf.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A GWTCSS if statement. The elif and else constructs are modeled as nested if
+ * statement is the elseNodes.
+ */
+public class CssIf extends CssNode implements HasNodes {
+  private final List<CssNode> elseNodes = new ArrayList<CssNode>();
+  private final List<CssNode> nodes = new ArrayList<CssNode>();
+  private String expression;
+  private boolean isNegated;
+  private String property;
+  private String[] propertyValues;
+
+  public List<CssNode> getElseNodes() {
+    return elseNodes;
+  }
+
+  public String getExpression() {
+    return expression;
+  }
+
+  public List<CssNode> getNodes() {
+    return nodes;
+  }
+
+  public String getPropertyName() {
+    return property;
+  }
+
+  public String[] getPropertyValues() {
+    return propertyValues;
+  }
+
+  public boolean isNegated() {
+    return isNegated;
+  }
+
+  public void setExpression(String expression) {
+    this.expression = expression;
+  }
+
+  public void setNegated(boolean isNegated) {
+    this.isNegated = isNegated;
+  }
+
+  public void setProperty(String property) {
+    this.property = property;
+  }
+
+  public void setPropertyValues(String[] propertyValues) {
+    this.propertyValues = propertyValues;
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    if (visitor.visit(this, context)) {
+      visitor.acceptWithInsertRemove(nodes);
+      visitor.acceptWithInsertRemove(elseNodes);
+    }
+    visitor.endVisit(this, context);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssMediaRule.java b/user/src/com/google/gwt/resources/css/ast/CssMediaRule.java
new file mode 100644
index 0000000..28c9192
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssMediaRule.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents an {@literal @}media rule.
+ */
+public class CssMediaRule extends CssNode implements HasNodes {
+  private final List<String> selectors = new ArrayList<String>();
+  private final List<CssNode> nodes = new ArrayList<CssNode>();
+
+  public List<String> getMedias() {
+    return selectors;
+  }
+
+  public List<CssNode> getNodes() {
+    return nodes;
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    if (visitor.visit(this, context)) {
+      visitor.acceptWithInsertRemove(nodes);
+    }
+    visitor.endVisit(this, context);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssModVisitor.java b/user/src/com/google/gwt/resources/css/ast/CssModVisitor.java
new file mode 100644
index 0000000..e0244fc
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssModVisitor.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.List;
+
+/**
+ * A visitor that can make structural modifications to a CSS tree.
+ */
+@SuppressWarnings("unchecked")
+public class CssModVisitor extends CssVisitor {
+  private class ListContext<T extends CssNode> implements Context {
+    private int index;
+    private List list;
+    private boolean removed;
+    private boolean replaced;
+
+    public boolean canInsert() {
+      return true;
+    }
+
+    public boolean canRemove() {
+      return true;
+    }
+
+    public void insertAfter(CssNode node) {
+      checkRemoved();
+      list.add(index + 1, node);
+      didChange = true;
+    }
+
+    public void insertBefore(CssNode node) {
+      checkRemoved();
+      list.add(index++, node);
+      didChange = true;
+    }
+
+    public void removeMe() {
+      checkState();
+      list.remove(index--);
+      didChange = removed = true;
+    }
+
+    public void replaceMe(CssNode node) {
+      checkState();
+      checkReplacement((CssNode) list.get(index), node);
+      list.set(index, node);
+      didChange = replaced = true;
+    }
+
+    protected void traverse(List<? extends CssNode> list) {
+      this.list = list;
+      for (index = 0; index < list.size(); ++index) {
+        removed = replaced = false;
+        doTraverse(list.get(index), this);
+      }
+    }
+
+    private void checkRemoved() {
+      if (removed) {
+        throw new CssCompilerException("Node was already removed");
+      }
+    }
+
+    private void checkState() {
+      checkRemoved();
+      if (replaced) {
+        throw new CssCompilerException("Node was already replaced");
+      }
+    }
+  }
+
+  protected static void checkReplacement(CssNode origNode, CssNode newNode) {
+    if (newNode == null) {
+      throw new CssCompilerException("Cannot replace with null");
+    }
+    if (newNode == origNode) {
+      throw new CssCompilerException(
+          "The replacement is the same as the original");
+    }
+  }
+
+  private boolean didChange;
+
+  public boolean didChange() {
+    return didChange;
+  }
+
+  @Override
+  protected void doAcceptWithInsertRemove(List<? extends CssNode> list) {
+    ListContext context = new ListContext();
+    context.traverse(list);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssNoFlip.java b/user/src/com/google/gwt/resources/css/ast/CssNoFlip.java
new file mode 100644
index 0000000..35604cd
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssNoFlip.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This is a container node to prevent the RTL visitor from affecting its child
+ * nodes.
+ */
+public class CssNoFlip extends CssNode implements HasNodes {
+  private List<CssNode> nodes = new ArrayList<CssNode>();
+
+  public List<CssNode> getNodes() {
+    return nodes;
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    if (visitor.visit(this, context)) {
+      visitor.acceptWithInsertRemove(nodes);
+    }
+    visitor.endVisit(this, context);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssNode.java b/user/src/com/google/gwt/resources/css/ast/CssNode.java
new file mode 100644
index 0000000..80d6fd5
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssNode.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import com.google.gwt.dev.util.DefaultTextOutput;
+import com.google.gwt.resources.css.CssGenerationVisitor;
+
+/**
+ * The basic type that composes a CSS tree.
+ */
+public abstract class CssNode implements CssVisitable {
+  @Override
+  public String toString() {
+    DefaultTextOutput out = new DefaultTextOutput(false);
+    CssGenerationVisitor v = new CssGenerationVisitor(out, true);
+    v.accept(this);
+    return out.toString();
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssNodeCloner.java b/user/src/com/google/gwt/resources/css/ast/CssNodeCloner.java
new file mode 100644
index 0000000..8e8d145
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssNodeCloner.java
@@ -0,0 +1,310 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * Clones CssNodes.
+ */
+public class CssNodeCloner extends CssVisitor {
+
+  /**
+   * Clone a list of nodes.
+   */
+  public static <T extends CssNode> List<T> clone(Class<T> clazz, List<T> nodes) {
+
+    // Push a fake context that will contain the cloned node
+    List<CssNode> topContext = new ArrayList<CssNode>();
+    final List<CssProperty> topProperties = new ArrayList<CssProperty>();
+    final List<CssSelector> topSelectors = new ArrayList<CssSelector>();
+
+    CssNodeCloner cloner = new CssNodeCloner();
+    cloner.curentNodes.push(topContext);
+    cloner.currentHasProperties = new HasProperties() {
+      public List<CssProperty> getProperties() {
+        return topProperties;
+      }
+    };
+    cloner.currentHasSelectors = new HasSelectors() {
+      public List<CssSelector> getSelectors() {
+        return topSelectors;
+      }
+    };
+
+    // Process the nodes
+    cloner.accept(nodes);
+
+    /*
+     * Return the requested data. Different AST nodes will have been collected
+     * in different parts of the initial context.
+     */
+    List<?> toIterate;
+    if (CssProperty.class.isAssignableFrom(clazz)) {
+      toIterate = topProperties;
+    } else if (CssSelector.class.isAssignableFrom(clazz)) {
+      toIterate = topSelectors;
+    } else {
+      toIterate = topContext;
+    }
+
+    assert toIterate.size() == nodes.size() : "Wrong number of nodes in top "
+        + "context. Expecting: " + nodes.size() + " Found: " + toIterate.size();
+
+    // Create the final return value
+    List<T> toReturn = new ArrayList<T>(toIterate.size());
+    for (Object node : toIterate) {
+      assert clazz.isInstance(node) : "Return type mismatch. Expecting: "
+          + clazz.getName() + " Found: " + node.getClass().getName();
+
+      // Cast to the correct type to avoid an unchecked generic cast
+      toReturn.add(clazz.cast(node));
+    }
+
+    return toReturn;
+  }
+
+  /**
+   * Clone a single node.
+   */
+  public static <T extends CssNode> T clone(Class<T> clazz, T node) {
+    return clone(clazz, Collections.singletonList(node)).get(0);
+  }
+
+  private HasProperties currentHasProperties;
+
+  private HasSelectors currentHasSelectors;
+
+  private final Stack<List<CssNode>> curentNodes = new Stack<List<CssNode>>();
+
+  private CssNodeCloner() {
+  }
+
+  @Override
+  public void endVisit(CssMediaRule x, Context ctx) {
+    popNodes(x);
+  }
+
+  @Override
+  public void endVisit(CssNoFlip x, Context ctx) {
+    popNodes(x);
+  }
+
+  @Override
+  public void endVisit(CssStylesheet x, Context ctx) {
+    popNodes(x);
+  }
+
+  @Override
+  public boolean visit(CssDef x, Context ctx) {
+    CssDef newDef = new CssDef(x.getKey());
+    newDef.getValues().addAll(x.getValues());
+
+    addToNodes(newDef);
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssEval x, Context ctx) {
+    assert x.getValues().size() == 1;
+    assert x.getValues().get(0).isExpressionValue() != null;
+
+    String value = x.getValues().get(0).isExpressionValue().getExpression();
+    CssEval newEval = new CssEval(x.getKey(), value);
+    addToNodes(newEval);
+    return true;
+  }
+
+  /**
+   * A CssIf has two lists of nodes, so we want to handle traversal in this
+   * visitor.
+   */
+  @Override
+  public boolean visit(CssIf x, Context ctx) {
+    CssIf newIf = new CssIf();
+
+    if (x.getExpression() != null) {
+      newIf.setExpression(x.getExpression());
+    } else {
+      newIf.setProperty(x.getPropertyName());
+
+      String[] newValues = new String[x.getPropertyValues().length];
+      System.arraycopy(x.getPropertyValues(), 0, newValues, 0, newValues.length);
+      newIf.setPropertyValues(newValues);
+
+      newIf.setNegated(x.isNegated());
+    }
+
+    // Handle the "then" part
+    pushNodes(newIf);
+    accept(x.getNodes());
+    popNodes(x, newIf);
+
+    /*
+     * Push the "else" part as though it were its own node, but don't add it as
+     * its own top-level node.
+     */
+    CollapsedNode oldElseNodes = new CollapsedNode(x.getElseNodes());
+    CollapsedNode newElseNodes = new CollapsedNode(newIf.getElseNodes());
+    pushNodes(newElseNodes, false);
+    accept(oldElseNodes);
+    popNodes(oldElseNodes, newElseNodes);
+
+    return false;
+  }
+
+  @Override
+  public boolean visit(CssMediaRule x, Context ctx) {
+    CssMediaRule newRule = new CssMediaRule();
+    newRule.getMedias().addAll(newRule.getMedias());
+
+    pushNodes(newRule);
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssNoFlip x, Context ctx) {
+    pushNodes(new CssNoFlip());
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssPageRule x, Context ctx) {
+    CssPageRule newRule = new CssPageRule();
+    newRule.setPseudoPage(x.getPseudoPage());
+    addToNodes(newRule);
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssProperty x, Context ctx) {
+    CssProperty newProperty = new CssProperty(x.getName(), x.getValues(),
+        x.isImportant());
+    currentHasProperties.getProperties().add(newProperty);
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssRule x, Context ctx) {
+    CssRule newRule = new CssRule();
+    addToNodes(newRule);
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssSelector x, Context ctx) {
+    CssSelector newSelector = new CssSelector(x.getSelector());
+    currentHasSelectors.getSelectors().add(newSelector);
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssSprite x, Context ctx) {
+    CssSprite newSprite = new CssSprite();
+    newSprite.setResourceFunction(x.getResourceFunction());
+    addToNodes(newSprite);
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssStylesheet x, Context ctx) {
+    CssStylesheet newSheet = new CssStylesheet();
+    pushNodes(newSheet);
+    return true;
+  }
+
+  @Override
+  public boolean visit(CssUrl x, Context ctx) {
+    assert x.getValues().size() == 1;
+    assert x.getValues().get(0).isIdentValue() != null;
+    String ident = x.getValues().get(0).isIdentValue().getIdent();
+    CssUrl newUrl = new CssUrl(x.getKey(), ident);
+    addToNodes(newUrl);
+    return true;
+  }
+
+  /**
+   * Add a cloned node instance to the output.
+   */
+  private void addToNodes(CssNode node) {
+    curentNodes.peek().add(node);
+
+    currentHasProperties = node instanceof HasProperties ? (HasProperties) node
+        : null;
+    currentHasSelectors = node instanceof HasSelectors ? (HasSelectors) node
+        : null;
+  }
+
+  /**
+   * Remove a frame.
+   * 
+   * @param original the node that was being cloned so that validity checks may
+   *          be performed
+   */
+  private List<CssNode> popNodes(HasNodes original) {
+    List<CssNode> toReturn = curentNodes.pop();
+
+    if (toReturn.size() != original.getNodes().size()) {
+      throw new RuntimeException("Insufficient number of nodes for a "
+          + original.getClass().getName() + " Expected: "
+          + original.getNodes().size() + " Found: " + toReturn.size());
+    }
+
+    return toReturn;
+  }
+
+  /**
+   * Remove a frame.
+   * 
+   * @param original the node that was being cloned so that validity checks may
+   *          be performed
+   * @param expected the HasNodes whose nodes were being populated by the frame
+   *          being removed.
+   */
+  private List<CssNode> popNodes(HasNodes original, HasNodes expected) {
+    List<CssNode> toReturn = popNodes(original);
+
+    if (toReturn != expected.getNodes()) {
+      throw new RuntimeException("Incorrect parent node list popped");
+    }
+
+    return toReturn;
+  }
+
+  /**
+   * Push a new frame, adding the new parent as a child of the current parent.
+   */
+  private <T extends CssNode & HasNodes> void pushNodes(T parent) {
+    pushNodes(parent, true);
+  }
+
+  /**
+   * Push a new frame.
+   * 
+   * @param addToNodes if <code>true</code> add the new parent node as a child
+   *          of the current parent.
+   */
+  private <T extends CssNode & HasNodes> void pushNodes(T parent,
+      boolean addToNodes) {
+    if (addToNodes) {
+      addToNodes(parent);
+    }
+    this.curentNodes.push(parent.getNodes());
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssPageRule.java b/user/src/com/google/gwt/resources/css/ast/CssPageRule.java
new file mode 100644
index 0000000..36423ce
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssPageRule.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A page rule in CSS.
+ */
+public class CssPageRule extends CssNode implements HasProperties {
+  private final List<CssProperty> nodes = new ArrayList<CssProperty>();
+  private String pseudoPage;
+
+  public List<CssProperty> getProperties() {
+    return nodes;
+  }
+
+  public String getPseudoPage() {
+    return pseudoPage;
+  }
+
+  public void setPseudoPage(String pseudoPage) {
+    this.pseudoPage = pseudoPage;
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    if (visitor.visit(this, context)) {
+      visitor.acceptWithInsertRemove(nodes);
+    }
+    visitor.endVisit(this, context);
+  }
+}
\ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/css/ast/CssProperty.java b/user/src/com/google/gwt/resources/css/ast/CssProperty.java
new file mode 100644
index 0000000..be4e91d
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssProperty.java
@@ -0,0 +1,389 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import com.google.gwt.core.ext.Generator;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Maps a named property to a Value.
+ */
+public class CssProperty extends CssNode {
+
+  /**
+   * Represents a sequence of no-arg method invocations.
+   */
+  public static class DotPathValue extends Value {
+    private final String path;
+    private final String suffix;
+
+    public DotPathValue(String path, String suffix) {
+      this.path = path;
+      this.suffix = suffix;
+    }
+
+    public String getExpression() {
+      return path.replace(".", "().") + "() + \"" + Generator.escape(suffix)
+          + "\"";
+    }
+
+    public String getPath() {
+      return path;
+    }
+
+    public String getSuffix() {
+      return suffix;
+    }
+
+    @Override
+    public DotPathValue isDotPathValue() {
+      return this;
+    }
+
+    public String toCss() {
+      return "value(\"" + path + "\""
+          + (suffix == null ? "" : (", \"" + suffix + "\"")) + ")";
+    }
+  }
+
+  /**
+   * Represents a literal Java expression.
+   */
+  public static class ExpressionValue extends Value {
+    private final String expression;
+
+    public ExpressionValue(String expression) {
+      this.expression = expression;
+    }
+
+    public String getExpression() {
+      return expression;
+    }
+
+    @Override
+    public ExpressionValue isExpressionValue() {
+      return this;
+    }
+
+    public String toCss() {
+      return "/* Java expression */";
+    }
+
+    /**
+     * For debugging only.
+     */
+    @Override
+    public String toString() {
+      return expression;
+    }
+  }
+
+  /**
+   * Represents an identifier in the CSS source.
+   */
+  public static class IdentValue extends Value {
+    private final String ident;
+
+    public IdentValue(String ident) {
+      this.ident = ident;
+    }
+
+    public String getExpression() {
+      return '"' + Generator.escape(ident) + '"';
+    }
+
+    public String getIdent() {
+      return ident;
+    }
+
+    @Override
+    public IdentValue isIdentValue() {
+      return this;
+    }
+
+    public String toCss() {
+      return ident;
+    }
+  }
+
+  /**
+   * Represents a space-separated list of Values.
+   */
+  public static class ListValue extends Value {
+    private final List<Value> values;
+
+    public ListValue(List<Value> values) {
+      this.values = Collections.unmodifiableList(new ArrayList<Value>(values));
+    }
+
+    public ListValue(Value... values) {
+      this(Arrays.asList(values));
+    }
+
+    public String getExpression() {
+      StringBuilder toReturn = new StringBuilder();
+      for (Iterator<Value> i = values.iterator(); i.hasNext();) {
+        toReturn.append(i.next().getExpression());
+        if (i.hasNext()) {
+          toReturn.append("+ \" \" +");
+        }
+      }
+      return toReturn.toString();
+    }
+
+    public List<Value> getValues() {
+      return values;
+    }
+
+    @Override
+    public ListValue isListValue() {
+      return this;
+    }
+
+    public String toCss() {
+      StringBuilder sb = new StringBuilder();
+      for (Value v : values) {
+        sb.append(" ").append(v.toCss());
+      }
+      return sb.substring(1);
+    }
+  }
+
+  /**
+   * Represents a numeric value, possibly with attached units.
+   */
+  public static class NumberValue extends Value {
+    private final String css;
+    private final String expression;
+    private final String units;
+    private final float value;
+
+    public NumberValue(float value) {
+      this(value, null);
+    }
+
+    public NumberValue(float value, String units) {
+      this.value = value;
+      this.units = units;
+
+      String s;
+      int i = (int) value;
+      if (i == value) {
+        s = String.valueOf(i);
+      } else {
+        s = String.valueOf(value);
+      }
+
+      if (units != null && value != 0) {
+        css = s + units;
+        expression = '"' + s + Generator.escape(units) + '"';
+      } else if (value == 0) {
+        css = "0";
+        expression = "\"0\"";
+      } else {
+        css = s;
+        expression = '"' + s + '"';
+      }
+    }
+
+    public String getExpression() {
+      return expression;
+    }
+
+    public String getUnits() {
+      return units;
+    }
+
+    public float getValue() {
+      return value;
+    }
+
+    @Override
+    public NumberValue isNumberValue() {
+      return this;
+    }
+
+    public String toCss() {
+      return css;
+    }
+  }
+
+  /**
+   * Represents one or more quoted string literals.
+   */
+  public static class StringValue extends Value {
+    private static String escapeValue(String s, boolean inDoubleQuotes) {
+      StringBuilder b = new StringBuilder();
+      for (char c : s.toCharArray()) {
+        if (Character.isISOControl(c)) {
+          b.append('\\').append(Integer.toHexString(c).toUpperCase()).append(
+              " ");
+        } else {
+          switch (c) {
+            case '\'':
+              // Special case a single quote in a pair of double quotes
+              if (inDoubleQuotes) {
+                b.append(c);
+              } else {
+                b.append("\\'");
+              }
+              break;
+
+            case '"':
+              // Special case a single quote in a pair of single quotes
+              if (inDoubleQuotes) {
+                b.append("\\\"");
+              } else {
+                b.append(c);
+              }
+              break;
+
+            case '\\':
+              b.append("\\\\");
+              break;
+
+            default:
+              b.append(c);
+          }
+        }
+      }
+
+      return b.toString();
+    }
+
+    private final String value;
+
+    public StringValue(String value) {
+      this.value = value;
+    }
+
+    public String getExpression() {
+      // The escaped CSS content has to be escaped to be a valid Java literal
+      return "\"" + Generator.escape(toCss()) + "\"";
+    }
+
+    public String getValue() {
+      return value;
+    }
+
+    @Override
+    public StringValue isStringValue() {
+      return this;
+    }
+
+    /**
+     * Returns a escaped, quoted representation of the underlying value.
+     */
+    public String toCss() {
+      return '"' + escapeValue(value, true) + '"';
+    }
+  }
+
+  /**
+   * An abstract encapsulation of property values in GWT CSS.
+   */
+  public abstract static class Value {
+    /**
+     * Generate a Java expression whose execution results in the value.
+     */
+    public abstract String getExpression();
+
+    public DotPathValue isDotPathValue() {
+      return null;
+    }
+
+    public ExpressionValue isExpressionValue() {
+      return null;
+    }
+
+    public IdentValue isIdentValue() {
+      return null;
+    }
+
+    public ListValue isListValue() {
+      return null;
+    }
+
+    public NumberValue isNumberValue() {
+      return null;
+    }
+
+    public StringValue isStringValue() {
+      return null;
+    }
+
+    /**
+     * Generate a CSS expression that represents the Value.
+     */
+    public abstract String toCss();
+
+    /**
+     * For debugging only.
+     */
+    @Override
+    public String toString() {
+      return toCss();
+    }
+  }
+
+  private boolean important;
+
+  private String name;
+  private ListValue value;
+
+  public CssProperty(String name, Value value, boolean important) {
+    this.name = name;
+    setValue(value);
+    this.important = important;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public ListValue getValues() {
+    return value;
+  }
+
+  public boolean isImportant() {
+    return important;
+  }
+
+  public void setImportant(boolean important) {
+    this.important = important;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public void setValue(Value value) {
+    this.value = value.isListValue();
+    if (this.value == null) {
+      this.value = new ListValue(value);
+    }
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    visitor.visit(this, context);
+    visitor.endVisit(this, context);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssRule.java b/user/src/com/google/gwt/resources/css/ast/CssRule.java
new file mode 100644
index 0000000..6cb06ff
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssRule.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 
+ */
+public class CssRule extends CssNode implements HasProperties, HasSelectors {
+  protected final List<CssProperty> properties = new ArrayList<CssProperty>();
+  protected final List<CssSelector> selectors = new ArrayList<CssSelector>();
+
+  public List<CssProperty> getProperties() {
+    return properties;
+  }
+
+  public List<CssSelector> getSelectors() {
+    return selectors;
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    if (visitor.visit(this, context)) {
+      visitor.acceptWithInsertRemove(selectors);
+      visitor.acceptWithInsertRemove(properties);
+    }
+    visitor.endVisit(this, context);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssSelector.java b/user/src/com/google/gwt/resources/css/ast/CssSelector.java
new file mode 100644
index 0000000..5d52ed1
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssSelector.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+/**
+ * 
+ */
+public class CssSelector extends CssNode {
+  /*
+   * TODO: Evaluate whether or not we need to have a type hierarchy of
+   * selectors.
+   */
+  private String selector;
+
+  public CssSelector(String selector) {
+    this.selector = selector;
+  }
+
+  public String getSelector() {
+    return selector;
+  }
+
+  public void setSelector(String selector) {
+    this.selector = selector;
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    visitor.visit(this, context);
+    visitor.endVisit(this, context);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssSprite.java b/user/src/com/google/gwt/resources/css/ast/CssSprite.java
new file mode 100644
index 0000000..0d563f9
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssSprite.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import com.google.gwt.resources.css.ast.CssProperty.ListValue;
+import com.google.gwt.resources.css.ast.CssProperty.StringValue;
+import com.google.gwt.resources.css.ast.CssProperty.Value;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+/**
+ * Represents a sprited image. This is basically a normal CssRule, except for
+ * one well-known property {@value CssSprite#IMAGE_PROPERTY_NAME}, which
+ * specifies the name of an ImageResource accessor.
+ */
+public class CssSprite extends CssRule {
+
+  public static final String IMAGE_PROPERTY_NAME = "gwt-image";
+
+  /**
+   * A facade for the underlying CssProperty list maintained by CssRule. We
+   * override the add and set methods to intercept the
+   * {@value CssSprite#IMAGE_PROPERTY_NAME} property.
+   */
+  private class SpritePropertyList implements List<CssProperty> {
+    private final List<CssProperty> source;
+
+    public SpritePropertyList(List<CssProperty> source) {
+      this.source = source;
+    }
+
+    public boolean add(CssProperty o) {
+      if (!processProperty(o)) {
+        return source.add(o);
+      } else {
+        return false;
+      }
+    }
+
+    public void add(int index, CssProperty element) {
+      if (!processProperty(element)) {
+        source.add(index, element);
+      }
+    }
+
+    public boolean addAll(Collection<? extends CssProperty> c) {
+      return source.addAll(c);
+    }
+
+    public boolean addAll(int index, Collection<? extends CssProperty> c) {
+      return source.addAll(index, c);
+    }
+
+    public void clear() {
+      source.clear();
+    }
+
+    public boolean contains(Object o) {
+      return source.contains(o);
+    }
+
+    public boolean containsAll(Collection<?> c) {
+      return source.containsAll(c);
+    }
+
+    public boolean equals(Object o) {
+      return source.equals(o);
+    }
+
+    public CssProperty get(int index) {
+      return source.get(index);
+    }
+
+    public int hashCode() {
+      return source.hashCode();
+    }
+
+    public int indexOf(Object o) {
+      return source.indexOf(o);
+    }
+
+    public boolean isEmpty() {
+      return source.isEmpty();
+    }
+
+    public Iterator<CssProperty> iterator() {
+      return source.iterator();
+    }
+
+    public int lastIndexOf(Object o) {
+      return source.lastIndexOf(o);
+    }
+
+    public ListIterator<CssProperty> listIterator() {
+      return source.listIterator();
+    }
+
+    public ListIterator<CssProperty> listIterator(int index) {
+      return source.listIterator(index);
+    }
+
+    public CssProperty remove(int index) {
+      return source.remove(index);
+    }
+
+    public boolean remove(Object o) {
+      return source.remove(o);
+    }
+
+    public boolean removeAll(Collection<?> c) {
+      return source.removeAll(c);
+    }
+
+    public boolean retainAll(Collection<?> c) {
+      return source.retainAll(c);
+    }
+
+    public CssProperty set(int index, CssProperty element) {
+      if (!processProperty(element)) {
+        return source.set(index, element);
+      } else {
+        return source.remove(index);
+      }
+    }
+
+    public int size() {
+      return source.size();
+    }
+
+    public List<CssProperty> subList(int fromIndex, int toIndex) {
+      return source.subList(fromIndex, toIndex);
+    }
+
+    public Object[] toArray() {
+      return source.toArray();
+    }
+
+    public <T> T[] toArray(T[] a) {
+      return source.toArray(a);
+    }
+  }
+
+  private String resourceFunction;
+
+  @Override
+  public List<CssProperty> getProperties() {
+    return new SpritePropertyList(super.getProperties());
+  }
+
+  public String getResourceFunction() {
+    return resourceFunction;
+  }
+
+  public void setResourceFunction(String resourceFunction) {
+    this.resourceFunction = resourceFunction;
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    if (visitor.visit(this, context)) {
+      visitor.acceptWithInsertRemove(selectors);
+      visitor.acceptWithInsertRemove(getProperties());
+    }
+    visitor.endVisit(this, context);
+  }
+
+  private boolean processProperty(CssProperty property) {
+    if (IMAGE_PROPERTY_NAME.equals(property.getName())) {
+      setImageProperty(property.getValues());
+      return true;
+    }
+    return false;
+  }
+
+  private void setImageProperty(Value value) {
+    StringValue stringValue;
+    ListValue listValue;
+
+    if ((stringValue = value.isStringValue()) != null) {
+      resourceFunction = stringValue.getValue();
+
+      // Allow the user to use both raw idents and quoted strings
+      if (resourceFunction.startsWith("\"")) {
+        resourceFunction = resourceFunction.substring(1,
+            resourceFunction.length() - 1);
+      }
+
+    } else if ((listValue = value.isListValue()) != null) {
+      List<Value> values = listValue.getValues();
+      if (values.size() == 1) {
+        setImageProperty(values.get(0));
+      }
+
+    } else {
+      throw new IllegalArgumentException("The " + IMAGE_PROPERTY_NAME
+          + " property of @sprite must have exactly one value");
+    }
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssStylesheet.java b/user/src/com/google/gwt/resources/css/ast/CssStylesheet.java
new file mode 100644
index 0000000..743d54e
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssStylesheet.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 
+ */
+public class CssStylesheet extends CssNode implements HasNodes {
+  private List<CssNode> rules = new ArrayList<CssNode>();
+
+  public List<CssNode> getNodes() {
+    return rules;
+  }
+
+  public void traverse(CssVisitor visitor, Context context) {
+    if (visitor.visit(this, context)) {
+      visitor.acceptWithInsertRemove(rules);
+    }
+    visitor.endVisit(this, context);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssUrl.java b/user/src/com/google/gwt/resources/css/ast/CssUrl.java
new file mode 100644
index 0000000..17f175c
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssUrl.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import com.google.gwt.resources.css.ast.CssProperty.IdentValue;
+import com.google.gwt.resources.css.ast.CssProperty.Value;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A reference to a DataResource that results in a url expression being inserted
+ * into the generated CSS.
+ */
+public class CssUrl extends CssDef {
+  private final List<Value> values;
+
+  public CssUrl(String key, String functionPath) {
+    super(key);
+    Value functionValue = new IdentValue(functionPath);
+    values = Collections.singletonList(functionValue);
+  }
+
+  @Override
+  public List<Value> getValues() {
+    return values;
+  }
+
+  @Override
+  public void traverse(CssVisitor visitor, Context context) {
+    visitor.visit(this, context);
+    visitor.endVisit(this, context);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssVisitable.java b/user/src/com/google/gwt/resources/css/ast/CssVisitable.java
new file mode 100644
index 0000000..335638d
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssVisitable.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+/**
+ * Allows traversal of a CSS tree.
+ */
+public interface CssVisitable {
+  void traverse(CssVisitor visitor, Context context);
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssVisitor.java b/user/src/com/google/gwt/resources/css/ast/CssVisitor.java
new file mode 100644
index 0000000..9c4edc9
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/CssVisitor.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.List;
+
+/**
+ * The base class for visiting a CSS tree.
+ */
+public class CssVisitor {
+  protected static final Context UNMODIFIABLE_CONTEXT = new Context() {
+
+    public boolean canInsert() {
+      return false;
+    }
+
+    public boolean canRemove() {
+      return false;
+    }
+
+    public void insertAfter(CssNode node) {
+      throw new UnsupportedOperationException();
+    }
+
+    public void insertBefore(CssNode node) {
+      throw new UnsupportedOperationException();
+    }
+
+    public void removeMe() {
+      throw new UnsupportedOperationException();
+    }
+
+    public void replaceMe(CssNode node) {
+      throw new UnsupportedOperationException();
+    }
+  };
+
+  public final void accept(List<? extends CssNode> nodes) {
+    doAccept(nodes);
+  }
+
+  public final <T extends CssNode> T accept(T node) {
+    return doAccept(node);
+  }
+
+  public final void acceptWithInsertRemove(List<? extends CssNode> nodes) {
+    doAcceptWithInsertRemove(nodes);
+  }
+
+  public void endVisit(CssDef x, Context ctx) {
+  }
+
+  public void endVisit(CssEval x, Context ctx) {
+  }
+
+  public void endVisit(CssIf x, Context ctx) {
+  }
+
+  public void endVisit(CssMediaRule x, Context ctx) {
+  }
+
+  public void endVisit(CssNoFlip x, Context ctx) {
+  }
+
+  public void endVisit(CssPageRule x, Context ctx) {
+  }
+
+  public void endVisit(CssProperty x, Context ctx) {
+  }
+
+  public void endVisit(CssRule x, Context ctx) {
+  }
+
+  public void endVisit(CssSelector x, Context ctx) {
+  }
+
+  public void endVisit(CssSprite x, Context ctx) {
+  }
+
+  public void endVisit(CssStylesheet x, Context ctx) {
+  }
+
+  public void endVisit(CssUrl x, Context ctx) {
+  }
+
+  public boolean visit(CssDef x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssEval x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssIf x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssMediaRule x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssNoFlip x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssPageRule x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssProperty x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssRule x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssSelector x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssSprite x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssStylesheet x, Context ctx) {
+    return true;
+  }
+
+  public boolean visit(CssUrl x, Context ctx) {
+    return true;
+  }
+
+  protected void doAccept(List<? extends CssNode> list) {
+    for (CssNode node : list) {
+      doTraverse(node, UNMODIFIABLE_CONTEXT);
+    }
+  }
+
+  protected <T extends CssNode> T doAccept(T node) {
+    doTraverse(node, UNMODIFIABLE_CONTEXT);
+    return node;
+  }
+
+  protected void doAcceptWithInsertRemove(List<? extends CssNode> list) {
+    for (CssNode node : list) {
+      doTraverse(node, UNMODIFIABLE_CONTEXT);
+    }
+  }
+
+  protected final void doTraverse(CssNode node, Context ctx) {
+    try {
+      node.traverse(this, ctx);
+    } catch (Throwable e) {
+      throw translateException(node, e);
+    }
+  }
+
+  private CssCompilerException translateException(CssNode node, Throwable e) {
+    CssCompilerException ex;
+    if (e instanceof CssCompilerException) {
+      ex = (CssCompilerException) e;
+    } else {
+      ex = new CssCompilerException("Unexpected error during visit.", e);
+    }
+    ex.addNode(node);
+    return ex;
+  }
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/HasNodes.java b/user/src/com/google/gwt/resources/css/ast/HasNodes.java
new file mode 100644
index 0000000..28d1c41
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/HasNodes.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.List;
+
+/**
+ * Indicates that the node contains other nodes.
+ */
+public interface HasNodes {
+  List<CssNode> getNodes();
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/HasProperties.java b/user/src/com/google/gwt/resources/css/ast/HasProperties.java
new file mode 100644
index 0000000..cb1eb47
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/HasProperties.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.List;
+
+/**
+ * Something that has CSS properties.
+ */
+public interface HasProperties {
+  List<CssProperty> getProperties();
+}
diff --git a/user/src/com/google/gwt/resources/css/ast/HasSelectors.java b/user/src/com/google/gwt/resources/css/ast/HasSelectors.java
new file mode 100644
index 0000000..bf2557f
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/ast/HasSelectors.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.css.ast;
+
+import java.util.List;
+
+/**
+ * Something that has CSS selectors.
+ */
+public interface HasSelectors {
+  List<CssSelector> getSelectors();
+}
diff --git a/user/src/com/google/gwt/resources/css/package-info.java b/user/src/com/google/gwt/resources/css/package-info.java
new file mode 100644
index 0000000..a930495
--- /dev/null
+++ b/user/src/com/google/gwt/resources/css/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+/**
+ * Support package for manipulating CSS resources.
+ */
+@com.google.gwt.util.PreventSpuriousRebuilds
+package com.google.gwt.resources.css;
\ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/ext/ClientBundleFields.java b/user/src/com/google/gwt/resources/ext/ClientBundleFields.java
new file mode 100644
index 0000000..205774e
--- /dev/null
+++ b/user/src/com/google/gwt/resources/ext/ClientBundleFields.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.ext;
+
+import com.google.gwt.core.ext.typeinfo.JType;
+
+/**
+ * Allows ResourceGenerators to define fields within the implementation class
+ * for a bundle type. An instance of this interface will be provided via the
+ * {@link ResourceGenerator#createFields} method.
+ * <p>
+ * Because multiple, unrelated ResourceGenerators may be generating method
+ * implementations within a single bundle implementation, it is necessary to
+ * ensure that they do not attempt to declare multiple fields with the same
+ * name. The methods in this interface will provide a guaranteed-unique
+ * identifier to use when generating method implementations.
+ * <p>
+ * Multiple invocations of the {@link #define} method with the same inputs will
+ * result in different identifiers being produced.
+ */
+public interface ClientBundleFields {
+  /**
+   * Adds a field to the bundle. Equivalent to
+   * <code>defineField(type, name, null, true, false)</code>.
+   * 
+   * @param type the declared type of the field
+   * @param name a Java identifier to be used as the basis for the name of the
+   *          field
+   * @return the identifier that must be used to access the field
+   */
+  String define(JType type, String name);
+
+  /**
+   * Adds a field to the bundle.
+   * 
+   * @param type the declared type of the field
+   * @param name a Java identifier to be used as the basis for the name of the
+   *          field
+   * @param initializer a Java expression that will be used as the field's
+   *          initializer, or <code>null</code> if no initialization expression
+   *          is desired
+   * @param isStatic if <code>true</code> the field will be declared to be
+   *          static
+   * @param isFinal if <code>true</code> the fields will be declared as final
+   * @return the identifier that must be used to access the field
+   */
+  String define(JType type, String name, String initializer, boolean isStatic,
+      boolean isFinal);
+}
diff --git a/user/src/com/google/gwt/resources/ext/ClientBundleRequirements.java b/user/src/com/google/gwt/resources/ext/ClientBundleRequirements.java
new file mode 100644
index 0000000..caea394
--- /dev/null
+++ b/user/src/com/google/gwt/resources/ext/ClientBundleRequirements.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.ext;
+
+import com.google.gwt.core.ext.BadPropertyValueException;
+
+/**
+ * Allows ResourceGenerators to indicate how their generated resources may be
+ * affected by their execution environment. An instance of this type will be
+ * provided to the ResourceGenerator via the {@link ResourceGenerator#prepare}
+ * method.
+ */
+public interface ClientBundleRequirements {
+  /**
+   * Indicates that the ResourcePrototype implementation generated by a
+   * ResourceGenerator is sensitive to the value of the specified
+   * deferred-binding property. This method should be called when the behavior
+   * of the ResourcePrototype must differ between permutations of the compiled
+   * output. For example, some resource implementations may be sensitive to the
+   * <code>user.agent</code> deferred-binding property, and would call this
+   * method with the literal string <code>user.agent</code>.
+   * 
+   * @param propertyName the name of the deferred-binding property
+   * @throws BadPropertyValueException if <code>propertyName</code> is not a
+   *           valid deferred-binding property.
+   */
+  void addPermutationAxis(String propertyName) throws BadPropertyValueException;
+}
diff --git a/user/src/com/google/gwt/resources/ext/ResourceContext.java b/user/src/com/google/gwt/resources/ext/ResourceContext.java
new file mode 100644
index 0000000..409dc31
--- /dev/null
+++ b/user/src/com/google/gwt/resources/ext/ResourceContext.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.ext;
+
+import com.google.gwt.core.ext.GeneratorContext;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+
+import java.net.URL;
+
+/**
+ * Context object for ResourceGenerators. An instance of this type will be
+ * provided by the resource generation framework to implementations of
+ * ResourceGenerator via {@link ResourceGenerator#init}. Because this interface
+ * is not intended to be implemented by end-users, the API provided by this
+ * interface may be extended in the future.
+ * <p>
+ * Depending on the optimizations made by the implementation of {@link #deploy},
+ * the resulting URL may or may not be compatible with standard
+ * {@link com.google.gwt.http.client.RequestBuilder} / XMLHttpRequest security
+ * semantics. If the resource is intended to be used with XHR, the
+ * <code>xhrCompatible</code> paramater should be set to <code>true</code> when
+ * invoking {@link #deploy}.
+ * </p>
+ */
+public interface ResourceContext {
+
+  /**
+   * Cause a specific collection of bytes to be available in the program's
+   * compiled output. The return value of this method is a Java expression which
+   * will evaluate to the location of the resource at runtime. The exact format
+   * should not be depended upon.
+   * 
+   * @param suggestedFileName an unobfuscated filename to possibly use for the
+   *          resource
+   * @param mimeType the MIME type of the data being provided
+   * @param data the bytes to add to the output
+   * @param xhrCompatible enforces compatibility with security restrictions if
+   *          the resource is intended to be accessed via an XMLHttpRequest.
+   * @return a Java expression which will evaluate to the location of the
+   *         provided resource at runtime.
+   */
+  String deploy(String suggestedFileName, String mimeType, byte[] data,
+      boolean xhrCompatible) throws UnableToCompleteException;
+
+  /**
+   * Cause a specific collection of bytes to be available in the program's
+   * compiled output. The return value of this method is a Java expression which
+   * will evaluate to the location of the resource at runtime. The exact format
+   * should not be depended upon.
+   * 
+   * @param resource the resource to add to the compiled output
+   * @param xhrCompatible enforces compatibility with security restrictions if
+   *          the resource is intended to be accessed via an XMLHttpRequest.
+   * @return a Java expression which will evaluate to the location of the
+   *         provided resource at runtime.
+   */
+  String deploy(URL resource, boolean xhrCompatible)
+      throws UnableToCompleteException;
+
+  /**
+   * Return the interface type of the resource bundle being generated.
+   */
+  JClassType getClientBundleType();
+
+  /**
+   * Return the GeneratorContext in which the overall resource generation
+   * framework is being run. Implementations of ResourceGenerator should prefer
+   * {@link #addToOutput} over {@link GeneratorContext#tryCreateResource} in
+   * order to take advantage of serving optimizations that can be performed by
+   * the bundle architecture.
+   */
+  GeneratorContext getGeneratorContext();
+
+  /**
+   * Returns the simple source name of the implementation of the bundle being
+   * generated. This can be used during code-generation to refer to the instance
+   * of the bundle (e.g. via <code>SimpleSourceName.this</code>).
+   * 
+   * @throws IllegalStateException if this method is called during
+   *           {@link ResourceGenerator#init} or
+   *           {@link ResourceGenerator#prepare} methods.
+   */
+  String getImplementationSimpleSourceName() throws IllegalStateException;
+
+  /**
+   * Indicates if the runtime context supports data: urls. When data URLs are
+   * supported by the context, aggregation of resource data into larger payloads
+   * is discouraged, as it offers reduced benefit to the application at runtime.
+   */
+  boolean supportsDataUrls();
+}
diff --git a/user/src/com/google/gwt/resources/ext/ResourceGenerator.java b/user/src/com/google/gwt/resources/ext/ResourceGenerator.java
new file mode 100644
index 0000000..2a61d56
--- /dev/null
+++ b/user/src/com/google/gwt/resources/ext/ResourceGenerator.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.ext;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+
+/**
+ * Encapsulates per-type resource generation logic. This type is used only by
+ * developers who wish to add additional resource types to the resource
+ * generation system. Implementations are paired with one or more interfaces
+ * derived from ResourcePrototype that have been annotated with an
+ * {@link ResourceGeneratorType} annotation. Instances of ResourceGenerator must
+ * support default-instantiation (i.e. via {@link Class#newInstance()}).
+ * <p>
+ * The methods on an instance of ResourceGenerator will be called in the
+ * following order by the resource generation system:
+ * <ol>
+ * <li>{@link #init}</li>
+ * <li>
+ * {@link #prepare} once for each method</li>
+ * <li>Based on the requirements specified by the ResourceGenerator, the
+ * framework may decide that no further action is required. If this is the case,
+ * the framework will immediately invoke {@link #finish}.</li>
+ * <li>{@link #createFields}</li>
+ * <li>{@link #createAssignment} once for each method</li>
+ * <li>{@link #finish}</li>
+ * </ol>
+ * <p>
+ * The methods {@link #prepare} and {@link #createAssignment} will be called
+ * only with those methods whose ResourcePrototype-derived type specifies the
+ * particular type of ResourceGenerator as the implementor. The relative order
+ * in which ResourceGenerators are invoked and the specific order in which the
+ * bundle's methods are presented is undefined.
+ * <p>
+ * Direct access to the contents of the generated bundle implementation is
+ * intentionally limited to prevent unrelated ResourceGenerators from
+ * potentially creating namespace conflicts or generating invalid Java source.
+ * 
+ * @see ResourceGeneratorUtil
+ */
+public interface ResourceGenerator {
+
+  /**
+   * Produce the right-hand-side of a Java assignment expression to provide the
+   * singleton instance object for a particular resource.
+   * <p>
+   * Example:
+   * 
+   * <pre>
+   * new MySampleResource() { public Foo getFoo() { ... } }
+   * </pre>
+   */
+  String createAssignment(TreeLogger logger, ResourceContext context,
+      JMethod method) throws UnableToCompleteException;
+
+  /**
+   * The ResourceGenerator can create fields within the implementation of the
+   * bundle type. The Fields object passed into this method is used to declare,
+   * and possibly initialize, Java fields within the final implementation of the
+   * resource bundle type.
+   * <p>
+   * The Fields instance should not be retained beyond the lifetime of this
+   * method as operation on this object is not defined after the implementation
+   * of this method returns.
+   */
+  void createFields(TreeLogger logger, ResourceContext context,
+      ClientBundleFields fields) throws UnableToCompleteException;
+
+  /**
+   * Called at the end of the resource generation phase and can be used to
+   * perform cleanup.
+   */
+  void finish(TreeLogger logger, ResourceContext context)
+      throws UnableToCompleteException;
+
+  /**
+   * Initialize the ResourceGenerator with the generation context that will
+   * remain valid for the duration of the resource-generation phase. The logger
+   * instance should not be retained; use the per-method loggers instead.
+   */
+  void init(TreeLogger logger, ResourceContext context)
+      throws UnableToCompleteException;
+
+  /**
+   * Called once for each method the ResourceGenerator is expected to handle.
+   * This allows cross-resource state to be accumulated, such as for data
+   * aggregation.
+   */
+  void prepare(TreeLogger logger, ResourceContext context,
+      ClientBundleRequirements requirements, JMethod method)
+      throws UnableToCompleteException;
+}
\ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/ext/ResourceGeneratorType.java b/user/src/com/google/gwt/resources/ext/ResourceGeneratorType.java
new file mode 100644
index 0000000..7489198
--- /dev/null
+++ b/user/src/com/google/gwt/resources/ext/ResourceGeneratorType.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.ext;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * Specifies the implementation of ResourceGenerator to use for a type of
+ * {@link com.google.gwt.resources.client.ResourcePrototype}.
+ */
+@Target(ElementType.TYPE)
+public @interface ResourceGeneratorType {
+  Class<? extends ResourceGenerator> value();
+}
diff --git a/user/src/com/google/gwt/resources/ext/ResourceGeneratorUtil.java b/user/src/com/google/gwt/resources/ext/ResourceGeneratorUtil.java
new file mode 100644
index 0000000..9b4e4a4
--- /dev/null
+++ b/user/src/com/google/gwt/resources/ext/ResourceGeneratorUtil.java
@@ -0,0 +1,317 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.ext;
+
+import com.google.gwt.core.ext.BadPropertyValueException;
+import com.google.gwt.core.ext.PropertyOracle;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.core.ext.typeinfo.JPackage;
+import com.google.gwt.resources.client.ClientBundle.Source;
+
+import java.lang.annotation.Annotation;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Utility methods for building ResourceGenerators.
+ */
+public final class ResourceGeneratorUtil {
+
+  /**
+   * These are type names from previous APIs or from APIs with similar
+   * functionality that might be confusing.
+   * 
+   * @see #checkForDeprecatedAnnotations
+   */
+  private static final String[] DEPRECATED_ANNOTATION_NAMES = {
+      "com.google.gwt.libideas.resources.client.ImmutableResourceBundle$Resource",
+      "com.google.gwt.user.client.ui.ImageBundle$Resource"};
+
+  private static final List<Class<? extends Annotation>> DEPRECATED_ANNOTATION_CLASSES;
+
+  static {
+    List<Class<? extends Annotation>> classes = new ArrayList<Class<? extends Annotation>>(
+        DEPRECATED_ANNOTATION_NAMES.length);
+
+    for (String name : DEPRECATED_ANNOTATION_NAMES) {
+      try {
+        Class<?> maybeAnnotation = Class.forName(name, false,
+            ResourceGeneratorUtil.class.getClassLoader());
+
+        // Possibly throws ClassCastException
+        Class<? extends Annotation> annotationClass = maybeAnnotation.asSubclass(Annotation.class);
+
+        classes.add(annotationClass);
+
+      } catch (ClassCastException e) {
+        // If it's not an Annotation type, we don't care about it
+      } catch (ClassNotFoundException e) {
+        // This is OK; the annotation doesn't exist.
+      }
+    }
+
+    if (classes.isEmpty()) {
+      DEPRECATED_ANNOTATION_CLASSES = Collections.emptyList();
+    } else {
+      DEPRECATED_ANNOTATION_CLASSES = Collections.unmodifiableList(classes);
+    }
+  }
+
+  /**
+   * Return the base filename of a resource. The behavior is similar to the unix
+   * command <code>basename</code>.
+   * 
+   * @param resource the URL of the resource
+   * @return the final name segment of the resource
+   */
+  public static String baseName(URL resource) {
+    String path = resource.getPath();
+    return path.substring(path.lastIndexOf('/') + 1);
+  }
+
+  /**
+   * Find all resources referenced by a method in a bundle. The method's
+   * {@link Source} annotation will be examined and the specified locations will
+   * be expanded into URLs by which they may be accessed on the local system.
+   * <p>
+   * This method is sensitive to the <code>locale</code> deferred-binding
+   * property and will attempt to use a best-match lookup by removing locale
+   * components.
+   * 
+   * @param logger a TreeLogger that will be used to report errors or warnings
+   * @param context the ResourceContext in which the ResourceGenerator is
+   *          operating
+   * @param classLoader the ClassLoader to use when locating resources
+   * @param method the method to examine for {@link Source} annotations
+   * @param defaultSuffixes if the supplied method does not have any
+   *          {@link Source} annotations, act as though a Source annotation was
+   *          specified, using the name of the method and each of supplied
+   *          extensions in the order in which they are specified
+   * @return URLs for each {@link Source} annotation value defined on the
+   *         method, or an empty array if no sources could be found.
+   * @throws UnableToCompleteException if ore or more of the sources could not
+   *           be found. The error will be reported via the <code>logger</code>
+   *           provided to this method
+   */
+  public static URL[] findResources(TreeLogger logger, ClassLoader classLoader,
+      ResourceContext context, JMethod method, String[] defaultSuffixes)
+      throws UnableToCompleteException {
+    logger = logger.branch(TreeLogger.DEBUG, "Finding resources");
+
+    String locale;
+    try {
+      PropertyOracle oracle = context.getGeneratorContext().getPropertyOracle();
+      locale = oracle.getPropertyValue(logger, "locale");
+    } catch (BadPropertyValueException e) {
+      locale = null;
+    }
+
+    checkForDeprecatedAnnotations(logger, method);
+
+    Source resourceAnnotation = method.getAnnotation(Source.class);
+    if (resourceAnnotation == null) {
+      if (defaultSuffixes != null) {
+        for (String extension : defaultSuffixes) {
+          logger.log(TreeLogger.SPAM, "Trying default extension " + extension);
+          URL resourceUrl = tryFindResource(classLoader,
+              getPathRelativeToPackage(method.getEnclosingType().getPackage(),
+                  method.getName() + extension), locale);
+
+          if (resourceUrl != null) {
+            return new URL[] {resourceUrl};
+          }
+        }
+      }
+      logger.log(TreeLogger.SPAM,
+          "No annotation and no hits with default extensions");
+      return new URL[0];
+    }
+
+    String[] resources = resourceAnnotation.value();
+
+    URL[] toReturn = new URL[resources.length];
+
+    boolean error = false;
+    int tagIndex = 0;
+    for (String resource : resources) {
+      // Try to find the resource relative to the package.
+      URL resourceURL = tryFindResource(classLoader, getPathRelativeToPackage(
+          method.getEnclosingType().getPackage(), resource), locale);
+
+      // If we didn't find the resource relative to the package, assume it is
+      // absolute.
+      if (resourceURL == null) {
+        resourceURL = tryFindResource(classLoader, resource, locale);
+      }
+
+      if (resourceURL == null) {
+        logger.log(TreeLogger.ERROR, "Resource " + resource
+            + " not found on classpath. Is the name specified as "
+            + "Class.getResource() would expect?");
+        error = true;
+      }
+
+      toReturn[tagIndex++] = resourceURL;
+    }
+
+    if (error) {
+      throw new UnableToCompleteException();
+    }
+
+    return toReturn;
+  }
+
+  /**
+   * Find all resources referenced by a method in a bundle. The method's
+   * {@link Source} annotation will be examined and the specified locations will
+   * be expanded into URLs by which they may be accessed on the local system.
+   * <p>
+   * This method is sensitive to the <code>locale</code> deferred-binding
+   * property and will attempt to use a best-match lookup by removing locale
+   * components.
+   * <p>
+   * The current Thread's context ClassLoader will be used to resolve resource
+   * locations. If it is necessary to alter the manner in which resources are
+   * resolved, use the overload that accepts an arbitrary ClassLoader.
+   * 
+   * @param logger a TreeLogger that will be used to report errors or warnings
+   * @param context the ResourceContext in which the ResourceGenerator is
+   *          operating
+   * @param method the method to examine for {@link Source} annotations
+   * @return URLs for each {@link Source} annotation value defined on the
+   *         method, or an empty array if no sources could be found.
+   * @throws UnableToCompleteException if ore or more of the sources could not
+   *           be found. The error will be reported via the <code>logger</code>
+   *           provided to this method
+   */
+  public static URL[] findResources(TreeLogger logger, ResourceContext context,
+      JMethod method) throws UnableToCompleteException {
+    return findResources(logger, context, method, new String[0]);
+  }
+
+  /**
+   * Find all resources referenced by a method in a bundle. The method's
+   * {@link Source} annotation will be examined and the specified locations will
+   * be expanded into URLs by which they may be accessed on the local system.
+   * <p>
+   * This method is sensitive to the <code>locale</code> deferred-binding
+   * property and will attempt to use a best-match lookup by removing locale
+   * components.
+   * <p>
+   * The current Thread's context ClassLoader will be used to resolve resource
+   * locations. If it is necessary to alter the manner in which resources are
+   * resolved, use the overload that accepts an arbitrary ClassLoader.
+   * 
+   * @param logger a TreeLogger that will be used to report errors or warnings
+   * @param context the ResourceContext in which the ResourceGenerator is
+   *          operating
+   * @param method the method to examine for {@link Source} annotations
+   * @param defaultSuffixes if the supplied method does not have any
+   *          {@link Source} annotations, act as though a Source annotation was
+   *          specified, using the name of the method and each of supplied
+   *          extensions in the order in which they are specified
+   * @return URLs for each {@link Source} annotation value defined on the
+   *         method, or an empty array if no sources could be found.
+   * @throws UnableToCompleteException if ore or more of the sources could not
+   *           be found. The error will be reported via the <code>logger</code>
+   *           provided to this method
+   */
+  public static URL[] findResources(TreeLogger logger, ResourceContext context,
+      JMethod method, String[] defaultSuffixes)
+      throws UnableToCompleteException {
+    return findResources(logger,
+        Thread.currentThread().getContextClassLoader(), context, method,
+        defaultSuffixes);
+  }
+
+  /**
+   * We want to warn the user about any annotations from ImageBundle or the old
+   * incubator code.
+   */
+  private static void checkForDeprecatedAnnotations(TreeLogger logger,
+      JMethod method) {
+
+    for (Class<? extends Annotation> annotationClass : DEPRECATED_ANNOTATION_CLASSES) {
+      if (method.isAnnotationPresent(annotationClass)) {
+        logger.log(TreeLogger.WARN, "Deprecated annotation used; expecting "
+            + Source.class.getCanonicalName() + " but found "
+            + annotationClass.getName() + " instead.  It is likely "
+            + "that undesired operation will occur.");
+      }
+    }
+  }
+
+  /**
+   * Converts a package relative path into an absolute path.
+   * 
+   * @param pkg the package
+   * @param path a path relative to the package
+   * @return an absolute path
+   */
+  private static String getPathRelativeToPackage(JPackage pkg, String path) {
+    return pkg.getName().replace('.', '/') + '/' + path;
+  }
+
+  /**
+   * This performs the locale lookup function for a given resource name.
+   * 
+   * @param classLoader the ClassLoader to use to load the resources
+   * @param resourceName the string name of the desired resource
+   * @param locale the locale of the current rebind permutation
+   * @return a URL by which the resource can be loaded, <code>null</code> if one
+   *         cannot be found
+   */
+  private static URL tryFindResource(ClassLoader classLoader,
+      String resourceName, String locale) {
+    URL toReturn = null;
+
+    // Look for locale-specific variants of individual resources
+    if (locale != null) {
+      // Convert language_country_variant to independent pieces
+      String[] localeSegments = locale.split("_");
+      int lastDot = resourceName.lastIndexOf(".");
+      String prefix = lastDot == -1 ? resourceName : resourceName.substring(0,
+          lastDot);
+      String extension = lastDot == -1 ? "" : resourceName.substring(lastDot);
+
+      for (int i = localeSegments.length - 1; i >= -1; i--) {
+        String localeInsert = "";
+        for (int j = 0; j <= i; j++) {
+          localeInsert += "_" + localeSegments[j];
+        }
+
+        toReturn = classLoader.getResource(prefix + localeInsert + extension);
+        if (toReturn != null) {
+          break;
+        }
+      }
+    } else {
+      toReturn = classLoader.getResource(resourceName);
+    }
+
+    return toReturn;
+  }
+
+  /**
+   * Utility class.
+   */
+  private ResourceGeneratorUtil() {
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rebind/context/AbstractClientBundleGenerator.java b/user/src/com/google/gwt/resources/rebind/context/AbstractClientBundleGenerator.java
new file mode 100644
index 0000000..65d51cd
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rebind/context/AbstractClientBundleGenerator.java
@@ -0,0 +1,587 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rebind.context;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.ext.BadPropertyValueException;
+import com.google.gwt.core.ext.Generator;
+import com.google.gwt.core.ext.GeneratorContext;
+import com.google.gwt.core.ext.PropertyOracle;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.core.ext.typeinfo.JType;
+import com.google.gwt.core.ext.typeinfo.TypeOracle;
+import com.google.gwt.dev.generator.NameFactory;
+import com.google.gwt.dev.util.Util;
+import com.google.gwt.resources.client.ClientBundle;
+import com.google.gwt.resources.client.ClientBundleWithLookup;
+import com.google.gwt.resources.client.ResourcePrototype;
+import com.google.gwt.resources.ext.ClientBundleFields;
+import com.google.gwt.resources.ext.ClientBundleRequirements;
+import com.google.gwt.resources.ext.ResourceContext;
+import com.google.gwt.resources.ext.ResourceGenerator;
+import com.google.gwt.resources.ext.ResourceGeneratorType;
+import com.google.gwt.resources.rg.BundleResourceGenerator;
+import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
+import com.google.gwt.user.rebind.SourceWriter;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * The base class for creating new ClientBundle implementations.
+ */
+public abstract class AbstractClientBundleGenerator extends Generator {
+
+  /**
+   * An implementation of FieldAccumulator that immediately composes its output
+   * into a StringWriter.
+   */
+  private static class FieldsImpl implements ClientBundleFields {
+    private final NameFactory factory = new NameFactory();
+    private final StringWriter buffer = new StringWriter();
+    private final PrintWriter pw = new PrintWriter(buffer);
+
+    public void addName(String name) {
+      factory.addName(name);
+    }
+
+    public String define(JType type, String name) {
+      return define(type, name, null, true, false);
+    }
+
+    public String define(JType type, String name, String initializer,
+        boolean isStatic, boolean isFinal) {
+
+      assert Util.isValidJavaIdent(name) : name
+          + " is not a valid Java identifier";
+
+      String ident = factory.createName(name);
+
+      pw.print("private ");
+
+      if (isStatic) {
+        pw.print("static ");
+      }
+
+      if (isFinal) {
+        pw.print("final ");
+      }
+
+      pw.print(type.getQualifiedSourceName());
+      pw.print(" ");
+      pw.print(ident);
+
+      if (initializer != null) {
+        pw.print(" = ");
+        pw.print(initializer);
+      }
+
+      pw.println(";");
+
+      return ident;
+    }
+
+    public String toString() {
+      pw.flush();
+      return buffer.getBuffer().toString();
+    }
+  }
+
+  private static class RequirementsImpl implements ClientBundleRequirements {
+    private final Set<String> axes = new HashSet<String>();
+    private final PropertyOracle oracle;
+
+    public RequirementsImpl(PropertyOracle oracle) {
+      this.oracle = oracle;
+    }
+
+    public void addPermutationAxis(String propertyName)
+        throws BadPropertyValueException {
+      oracle.getPropertyValue(TreeLogger.NULL, propertyName);
+      axes.add(propertyName);
+    }
+  }
+
+  public final String generate(TreeLogger logger,
+      GeneratorContext generatorContext, String typeName)
+      throws UnableToCompleteException {
+
+    // The TypeOracle knows about all types in the type system
+    TypeOracle typeOracle = generatorContext.getTypeOracle();
+
+    // Get a reference to the type that the generator should implement
+    JClassType sourceType = typeOracle.findType(typeName);
+
+    // Ensure that the requested type exists
+    if (sourceType == null) {
+      logger.log(TreeLogger.ERROR, "Could not find requested typeName");
+      throw new UnableToCompleteException();
+    } else if (sourceType.isInterface() == null) {
+      // The incoming type wasn't a plain interface, we don't support
+      // abstract base classes
+      logger.log(TreeLogger.ERROR, sourceType.getQualifiedSourceName()
+          + " is not an interface.", null);
+      throw new UnableToCompleteException();
+    }
+
+    /*
+     * This associates the methods to implement with the ResourceGenerator class
+     * that will generate the implementations of those methods.
+     */
+    Map<Class<? extends ResourceGenerator>, List<JMethod>> taskList = createTaskList(
+        logger, typeOracle, sourceType);
+
+    /*
+     * Additional objects that hold state during the generation process.
+     */
+    AbstractResourceContext resourceContext = createResourceContext(logger,
+        generatorContext, sourceType);
+    FieldsImpl fields = new FieldsImpl();
+    RequirementsImpl requirements = new RequirementsImpl(
+        generatorContext.getPropertyOracle());
+
+    /*
+     * Initialize the ResourceGenerators and prepare them for subsequent code
+     * generation.
+     */
+    Map<ResourceGenerator, List<JMethod>> generators = initAndPrepare(logger,
+        taskList, resourceContext, requirements);
+
+    /*
+     * Now that the ResourceGenerators have been initialized and prepared, we
+     * can compute the actual name of the implementation class in order to
+     * ensure that we use a distinct name between permutations.
+     */
+    String generatedSimpleSourceName = generateSimpleSourceName(logger,
+        resourceContext, requirements);
+
+    // Begin writing the generated source.
+    ClassSourceFileComposerFactory f = new ClassSourceFileComposerFactory(
+        sourceType.getPackage().getName(), generatedSimpleSourceName);
+
+    // The generated class needs to be able to determine the module base URL
+    f.addImport(GWT.class.getName());
+
+    // Used by the map methods
+    f.addImport(ResourcePrototype.class.getName());
+
+    // The whole point of this exercise
+    f.addImplementedInterface(sourceType.getQualifiedSourceName());
+
+    String createdClassName = f.getCreatedClassName();
+
+    // All source gets written through this Writer
+    PrintWriter out = generatorContext.tryCreate(logger,
+        sourceType.getPackage().getName(), generatedSimpleSourceName);
+
+    // If an implementation already exists, we don't need to do any work
+    if (out != null) {
+      SourceWriter sw = f.createSourceWriter(generatorContext, out);
+
+      // Set the now-calculated simple source name
+      resourceContext.setSimpleSourceName(generatedSimpleSourceName);
+
+      // Write the generated code to disk
+      createFieldsAndAssignments(logger, sw, generators, resourceContext,
+          fields);
+
+      // Print the accumulated field definitions
+      sw.println(fields.toString());
+
+      /*
+       * The map-accessor methods use JSNI and need a fully-qualified class
+       * name, but should not include any sub-bundles.
+       */
+      taskList.remove(BundleResourceGenerator.class);
+      writeMapMethods(logger, createdClassName, sw, taskList);
+
+      sw.commit(logger);
+    }
+
+    finish(logger, resourceContext, generators.keySet());
+
+    // Return the name of the concrete class
+    return createdClassName;
+  }
+
+  /**
+   * Create the ResourceContext object that will be used by
+   * {@link ResourceGenerator} subclasses. This is the primary way to implement
+   * custom logic in the resource generation pass.
+   */
+  protected abstract AbstractResourceContext createResourceContext(
+      TreeLogger logger, GeneratorContext context, JClassType resourceBundleType);
+
+  /**
+   * Create fields and assignments for a single ResourceGenerator.
+   */
+  private boolean createFieldsAndAssignments(TreeLogger logger,
+      ResourceContext resourceContext, ResourceGenerator rg,
+      List<JMethod> generatorMethods, SourceWriter sw, ClientBundleFields fields) {
+
+    // Defer failure until this phase has ended
+    boolean fail = false;
+
+    // Write all field values
+    try {
+      rg.createFields(logger.branch(TreeLogger.DEBUG, "Creating fields"),
+          resourceContext, fields);
+    } catch (UnableToCompleteException e) {
+      return false;
+    }
+
+    // Create the instance variables in the IRB subclass by calling
+    // writeAssignment() on the ResourceGenerator
+    for (JMethod m : generatorMethods) {
+      String rhs;
+
+      try {
+        rhs = rg.createAssignment(logger.branch(TreeLogger.DEBUG,
+            "Creating assignment for " + m.getName()), resourceContext, m);
+      } catch (UnableToCompleteException e) {
+        fail = true;
+        continue;
+      }
+
+      String ident = fields.define(m.getReturnType().isClassOrInterface(),
+          m.getName(), null, true, false);
+
+      // Strip off all but the access modifiers
+      sw.print(m.getReadableDeclaration(false, true, true, true, true));
+      sw.println(" {");
+      sw.indent();
+      sw.println("if (" + ident + " == null) {");
+      sw.indent();
+      sw.println(ident + " = " + rhs + ";");
+      sw.outdent();
+      sw.println("}");
+      sw.println("return " + ident + ";");
+      sw.outdent();
+      sw.println("}");
+    }
+
+    if (fail) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Create fields and assignments for multiple ResourceGenerators.
+   */
+  private void createFieldsAndAssignments(TreeLogger logger, SourceWriter sw,
+      Map<ResourceGenerator, List<JMethod>> generators,
+      ResourceContext resourceContext, ClientBundleFields fields)
+      throws UnableToCompleteException {
+    // Try to provide as many errors as possible before failing.
+    boolean success = true;
+
+    // Run the ResourceGenerators to generate implementations of the methods
+    for (Map.Entry<ResourceGenerator, List<JMethod>> entry : generators.entrySet()) {
+
+      success &= createFieldsAndAssignments(logger, resourceContext,
+          entry.getKey(), entry.getValue(), sw, fields);
+    }
+
+    if (!success) {
+      throw new UnableToCompleteException();
+    }
+  }
+
+  /**
+   * Given a ClientBundle subtype, compute which ResourceGenerators should
+   * implement which methods.
+   */
+  private Map<Class<? extends ResourceGenerator>, List<JMethod>> createTaskList(
+      TreeLogger logger, TypeOracle typeOracle, JClassType sourceType)
+      throws UnableToCompleteException {
+
+    Map<Class<? extends ResourceGenerator>, List<JMethod>> toReturn = new HashMap<Class<? extends ResourceGenerator>, List<JMethod>>();
+
+    JClassType bundleType = typeOracle.findType(ClientBundle.class.getName());
+    assert bundleType != null;
+
+    JClassType bundleWithLookupType = typeOracle.findType(ClientBundleWithLookup.class.getName());
+    assert bundleWithLookupType != null;
+
+    JClassType resourcePrototypeType = typeOracle.findType(ResourcePrototype.class.getName());
+    assert resourcePrototypeType != null;
+
+    // Accumulate as many errors as possible before failing
+    boolean throwException = false;
+
+    // Using overridable methods allows composition of interface types
+    for (JMethod m : sourceType.getOverridableMethods()) {
+      JClassType returnType = m.getReturnType().isClassOrInterface();
+
+      if (m.getEnclosingType().equals(bundleType)
+          || m.getEnclosingType().equals(bundleWithLookupType)) {
+        // Methods that we must generate, but that are not resources
+        continue;
+
+      } else if (!m.isAbstract()) {
+        // Covers the case of an abstract class base type
+        continue;
+
+      } else if (returnType == null
+          || !(returnType.isAssignableTo(resourcePrototypeType) || returnType.isAssignableTo(bundleType))) {
+        // Primitives and random other abstract methods
+        logger.log(TreeLogger.ERROR, "Unable to implement " + m.getName()
+            + " because it does not derive from "
+            + resourcePrototypeType.getQualifiedSourceName() + " or "
+            + bundleType.getQualifiedSourceName());
+        throwException = true;
+        continue;
+      }
+
+      try {
+        Class<? extends ResourceGenerator> clazz = findResourceGenerator(
+            logger, typeOracle, m);
+        List<JMethod> generatorMethods;
+        if (toReturn.containsKey(clazz)) {
+          generatorMethods = toReturn.get(clazz);
+        } else {
+          generatorMethods = new ArrayList<JMethod>();
+          toReturn.put(clazz, generatorMethods);
+        }
+
+        generatorMethods.add(m);
+      } catch (UnableToCompleteException e) {
+        throwException = true;
+      }
+    }
+
+    if (throwException) {
+      throw new UnableToCompleteException();
+    }
+
+    return toReturn;
+  }
+
+  /**
+   * Given a JMethod, find the a ResourceGenerator class that will be able to
+   * provide an implementation of the method.
+   */
+  private Class<? extends ResourceGenerator> findResourceGenerator(
+      TreeLogger logger, TypeOracle typeOracle, JMethod method)
+      throws UnableToCompleteException {
+
+    JClassType resourceType = method.getReturnType().isClassOrInterface();
+    assert resourceType != null;
+
+    List<JClassType> searchTypes = new ArrayList<JClassType>();
+    searchTypes.add(resourceType);
+
+    ResourceGeneratorType generatorType = null;
+
+    while (!searchTypes.isEmpty()) {
+      JClassType current = searchTypes.remove(0);
+      generatorType = current.getAnnotation(ResourceGeneratorType.class);
+      if (generatorType != null) {
+        break;
+      }
+
+      if (current.getSuperclass() != null) {
+        searchTypes.add(current.getSuperclass());
+      }
+
+      for (JClassType t : current.getImplementedInterfaces()) {
+        searchTypes.add(t);
+      }
+    }
+
+    if (generatorType == null) {
+      logger.log(TreeLogger.ERROR, "No @"
+          + ResourceGeneratorType.class.getName()
+          + " was specifed for resource type "
+          + resourceType.getQualifiedSourceName() + " or its supertypes");
+      throw new UnableToCompleteException();
+    }
+
+    return generatorType.value();
+  }
+
+  /**
+   * Call finish() on several ResourceGenerators.
+   */
+  private void finish(TreeLogger logger, ResourceContext context,
+      Collection<ResourceGenerator> generators)
+      throws UnableToCompleteException {
+    boolean fail = false;
+    // Finalize the ResourceGenerator
+    for (ResourceGenerator rg : generators) {
+      try {
+        rg.finish(
+            logger.branch(TreeLogger.DEBUG, "Finishing ResourceGenerator"),
+            context);
+      } catch (UnableToCompleteException e) {
+        fail = true;
+      }
+    }
+    if (fail) {
+      throw new UnableToCompleteException();
+    }
+  }
+
+  /**
+   * Given a user-defined type name, determine the type name for the generated
+   * class based on accumulated requirements.
+   */
+  private String generateSimpleSourceName(TreeLogger logger,
+      ResourceContext context, RequirementsImpl requirements)
+      throws UnableToCompleteException {
+    StringBuilder toReturn = new StringBuilder(
+        context.getClientBundleType().getQualifiedSourceName().replaceAll(
+            "[.$]", "_"));
+    Set<String> permutationAxes = new HashSet<String>(requirements.axes);
+    permutationAxes.add("locale");
+
+    try {
+      PropertyOracle oracle = context.getGeneratorContext().getPropertyOracle();
+      for (String property : permutationAxes) {
+        String value = oracle.getPropertyValue(logger, property);
+        toReturn.append("_" + value);
+      }
+    } catch (BadPropertyValueException e) {
+    }
+
+    toReturn.append("_" + getClass().getSimpleName());
+
+    return toReturn.toString();
+  }
+
+  private Map<ResourceGenerator, List<JMethod>> initAndPrepare(
+      TreeLogger logger,
+      Map<Class<? extends ResourceGenerator>, List<JMethod>> taskList,
+      ResourceContext resourceContext, ClientBundleRequirements requirements)
+      throws UnableToCompleteException {
+    // Try to provide as many errors as possible before failing.
+    boolean success = true;
+    Map<ResourceGenerator, List<JMethod>> toReturn = new IdentityHashMap<ResourceGenerator, List<JMethod>>();
+
+    // Run the ResourceGenerators to generate implementations of the methods
+    for (Map.Entry<Class<? extends ResourceGenerator>, List<JMethod>> entry : taskList.entrySet()) {
+
+      ResourceGenerator rg = instantiateResourceGenerator(logger,
+          entry.getKey());
+      toReturn.put(rg, entry.getValue());
+
+      success &= initAndPrepare(logger, resourceContext, rg, entry.getValue(),
+          requirements);
+    }
+
+    if (!success) {
+      throw new UnableToCompleteException();
+    }
+
+    return toReturn;
+  }
+
+  private boolean initAndPrepare(TreeLogger logger,
+      ResourceContext resourceContext, ResourceGenerator rg,
+      List<JMethod> generatorMethods, ClientBundleRequirements requirements) {
+    try {
+      rg.init(
+          logger.branch(TreeLogger.DEBUG, "Initializing ResourceGenerator"),
+          resourceContext);
+    } catch (UnableToCompleteException e) {
+      return false;
+    }
+
+    boolean fail = false;
+
+    // Prepare the ResourceGenerator by telling it all methods that it is
+    // expected to produce.
+    for (JMethod m : generatorMethods) {
+      try {
+        rg.prepare(logger.branch(TreeLogger.DEBUG, "Preparing method "
+            + m.getName()), resourceContext, requirements, m);
+      } catch (UnableToCompleteException e) {
+        fail = true;
+      }
+    }
+
+    return !fail;
+  }
+
+  /**
+   * Utility method to construct a ResourceGenerator that logs errors.
+   */
+  private <T extends ResourceGenerator> T instantiateResourceGenerator(
+      TreeLogger logger, Class<T> generatorClass)
+      throws UnableToCompleteException {
+    try {
+      return generatorClass.newInstance();
+    } catch (InstantiationException e) {
+      logger.log(TreeLogger.ERROR, "Unable to initialize ResourceGenerator", e);
+    } catch (IllegalAccessException e) {
+      logger.log(TreeLogger.ERROR, "Unable to instantiate ResourceGenerator. "
+          + "Does it have a public default constructor?", e);
+    }
+    throw new UnableToCompleteException();
+  }
+
+  private void writeMapMethods(TreeLogger logger, String createdClassName,
+      SourceWriter sw,
+      Map<Class<? extends ResourceGenerator>, List<JMethod>> taskList)
+      throws UnableToCompleteException {
+
+    // Complete the IRB contract
+    sw.println("public ResourcePrototype[] getResources() {");
+    sw.indent();
+    sw.println("return new ResourcePrototype[] {");
+    sw.indent();
+    for (List<JMethod> methods : taskList.values()) {
+      for (JMethod m : methods) {
+        sw.println(m.getName() + "(), ");
+      }
+    }
+    sw.outdent();
+    sw.println("};");
+    sw.outdent();
+    sw.println("}");
+
+    // Use a switch statement as a fast map
+    sw.println("public native ResourcePrototype "
+        + "getResource(String name) /*-{");
+    sw.indent();
+    sw.println("switch (name) {");
+    sw.indent();
+    for (List<JMethod> list : taskList.values()) {
+      for (JMethod m : list) {
+        sw.println("case '" + m.getName() + "': return this.@"
+            + createdClassName + "::" + (m.getName() + "()()") + ";");
+      }
+    }
+    sw.outdent();
+    sw.println("}");
+    sw.println("return null;");
+    sw.outdent();
+    sw.println("}-*/;");
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rebind/context/AbstractResourceContext.java b/user/src/com/google/gwt/resources/rebind/context/AbstractResourceContext.java
new file mode 100644
index 0000000..9e4e549
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rebind/context/AbstractResourceContext.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rebind.context;
+
+import com.google.gwt.core.ext.GeneratorContext;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.resources.ext.ResourceContext;
+
+/**
+ * Defines base methods for ResourceContext implementations.
+ */
+public abstract class AbstractResourceContext implements ResourceContext {
+  private final TreeLogger logger;
+  private final GeneratorContext context;
+  private final JClassType resourceBundleType;
+  private String simpleSourceName;
+
+  protected AbstractResourceContext(TreeLogger logger,
+      GeneratorContext context, JClassType resourceBundleType) {
+    this.logger = logger;
+    this.context = context;
+    this.resourceBundleType = resourceBundleType;
+  }
+
+  public JClassType getClientBundleType() {
+    return resourceBundleType;
+  }
+
+  public GeneratorContext getGeneratorContext() {
+    return context;
+  }
+
+  public String getImplementationSimpleSourceName() {
+    if (simpleSourceName == null) {
+      throw new IllegalStateException(
+          "Simple source name has not yet been set.");
+    }
+    return simpleSourceName;
+  }
+
+  protected TreeLogger getLogger() {
+    return logger;
+  }
+
+  void setSimpleSourceName(String name) {
+    simpleSourceName = name;
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rebind/context/InlineClientBundleGenerator.java b/user/src/com/google/gwt/resources/rebind/context/InlineClientBundleGenerator.java
new file mode 100644
index 0000000..ecbd37d
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rebind/context/InlineClientBundleGenerator.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rebind.context;
+
+import com.google.gwt.core.ext.GeneratorContext;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+
+/**
+ * This is a refinement that will use data urls for browsers that support them.
+ * Only files whose size are smaller than MAX_INLINE_SIZE will be inlined.
+ * Larger files will use the standard CacheBundle behavior.
+ * 
+ * @see "RFC 2397"
+ */
+public final class InlineClientBundleGenerator extends
+    AbstractClientBundleGenerator {
+  protected AbstractResourceContext createResourceContext(TreeLogger logger,
+      GeneratorContext context, JClassType resourceBundleType) {
+    return new InlineResourceContext(logger.branch(TreeLogger.DEBUG,
+        "Using inline resources", null), context, resourceBundleType);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rebind/context/InlineResourceContext.java b/user/src/com/google/gwt/resources/rebind/context/InlineResourceContext.java
new file mode 100644
index 0000000..53aef65
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rebind/context/InlineResourceContext.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rebind.context;
+
+import com.google.gwt.core.ext.GeneratorContext;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+
+class InlineResourceContext extends StaticResourceContext {
+  /**
+   * The largest file size that will be inlined. Note that this value is taken
+   * before any encodings are applied.
+   */
+  // The JLS specifies a maximum size for any string to be 2^16 characters, so
+  // we'll leave some padding. Assuming a Base64 encoding, it is true that
+  // (2 ^ 15) * 4/3 < 2 ^ 16, so we can safely inline files up to 32k.
+  private static final int MAX_INLINE_SIZE = 2 << 15;
+
+  InlineResourceContext(TreeLogger logger, GeneratorContext context,
+      JClassType resourceBundleType) {
+    super(logger, context, resourceBundleType);
+  }
+
+  @Override
+  public String deploy(String suggestedFileName, String mimeType, byte[] data,
+      boolean xhrCompatible) throws UnableToCompleteException {
+    TreeLogger logger = getLogger();
+
+    // data: URLs are not compatible with XHRs on FF and Safari browsers
+    if ((!xhrCompatible) && (data.length < MAX_INLINE_SIZE)) {
+      logger.log(TreeLogger.DEBUG, "Inlining", null);
+
+      // This is bad, but I am lazy and don't want to write _another_ encoder
+      sun.misc.BASE64Encoder enc = new sun.misc.BASE64Encoder();
+      String base64Contents = enc.encode(data).replaceAll("\\s+", "");
+
+      return "\"data:" + mimeType + ";base64," + base64Contents + "\"";
+    } else {
+      return super.deploy(suggestedFileName, mimeType, data, true);
+    }
+  }
+
+  @Override
+  public boolean supportsDataUrls() {
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/rebind/context/StaticClientBundleGenerator.java b/user/src/com/google/gwt/resources/rebind/context/StaticClientBundleGenerator.java
new file mode 100644
index 0000000..44f6534
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rebind/context/StaticClientBundleGenerator.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rebind.context;
+
+import com.google.gwt.core.ext.GeneratorContext;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+
+/**
+ * Copies selected files into module output with strong names and generates the
+ * ClientBundle mappings.
+ */
+public final class StaticClientBundleGenerator extends
+    AbstractClientBundleGenerator {
+
+  protected AbstractResourceContext createResourceContext(TreeLogger logger,
+      GeneratorContext context, JClassType resourceBundleType) {
+    return new StaticResourceContext(logger.branch(TreeLogger.DEBUG,
+        "Using static resources", null), context, resourceBundleType);
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rebind/context/StaticResourceContext.java b/user/src/com/google/gwt/resources/rebind/context/StaticResourceContext.java
new file mode 100644
index 0000000..a4beb90
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rebind/context/StaticResourceContext.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rebind.context;
+
+import com.google.gwt.core.ext.BadPropertyValueException;
+import com.google.gwt.core.ext.GeneratorContext;
+import com.google.gwt.core.ext.PropertyOracle;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.dev.util.Util;
+import com.google.gwt.resources.ext.ResourceGeneratorUtil;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URL;
+
+class StaticResourceContext extends AbstractResourceContext {
+  /**
+   * The name of a deferred binding property that determines whether or not this
+   * generator will rename the incoming resources to strong file names.
+   */
+  static final String ENABLE_RENAMING = "ClientBundle.enableRenaming";
+
+  StaticResourceContext(TreeLogger logger, GeneratorContext context,
+      JClassType resourceBundleType) {
+    super(logger, context, resourceBundleType);
+  }
+
+  public String deploy(String suggestedFileName, String mimeType, byte[] data,
+      boolean xhrCompatible) throws UnableToCompleteException {
+    TreeLogger logger = getLogger();
+    GeneratorContext context = getGeneratorContext();
+    PropertyOracle propertyOracle = context.getPropertyOracle();
+
+    // See if filename obfuscation should be enabled
+    String enableRenaming = null;
+    try {
+      enableRenaming = propertyOracle.getPropertyValue(logger, ENABLE_RENAMING);
+    } catch (BadPropertyValueException e) {
+      logger.log(TreeLogger.ERROR, "Bad value for " + ENABLE_RENAMING, e);
+      throw new UnableToCompleteException();
+    }
+
+    // Determine the final filename for the resource's file
+    String outputName;
+    if (Boolean.parseBoolean(enableRenaming)) {
+      String strongName = Util.computeStrongName(data);
+
+      // Determine the extension of the original file
+      String extension;
+      int lastIdx = suggestedFileName.lastIndexOf('.');
+      if (lastIdx != -1) {
+        extension = suggestedFileName.substring(lastIdx + 1);
+      } else {
+        extension = "noext";
+      }
+
+      // The name will be MD5.cache.ext
+      outputName = strongName + ".cache." + extension;
+
+    } else {
+      outputName = suggestedFileName.substring(suggestedFileName.lastIndexOf('/') + 1);
+    }
+
+    // Ask the context for an OutputStream into the named resource
+    OutputStream out = context.tryCreateResource(logger, outputName);
+
+    // This would be null if the resource has already been created in the
+    // output (because two or more resources had identical content).
+    if (out != null) {
+      try {
+        out.write(data);
+
+      } catch (IOException e) {
+        logger.log(TreeLogger.ERROR, "Unable to write data to output name "
+            + outputName, e);
+        throw new UnableToCompleteException();
+      }
+
+      // If there's an error, this won't be called and there will be nothing
+      // created in the output directory.
+      context.commitResource(logger, out);
+
+      logger.log(TreeLogger.DEBUG, "Copied " + data.length + " bytes to "
+          + outputName, null);
+    }
+
+    // Return a Java expression
+    return "GWT.getModuleBaseURL() + \"" + outputName + "\"";
+  }
+
+  public String deploy(URL resource, boolean xhrCompatible)
+      throws UnableToCompleteException {
+    String fileName = ResourceGeneratorUtil.baseName(resource);
+    byte[] bytes = Util.readURLAsBytes(resource);
+    try {
+      return deploy(fileName, resource.openConnection().getContentType(),
+          bytes, xhrCompatible);
+    } catch (IOException e) {
+      getLogger().log(TreeLogger.ERROR,
+          "Unable to determine mime type of resource", e);
+      throw new UnableToCompleteException();
+    }
+  }
+
+  public boolean supportsDataUrls() {
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/rg/AbstractResourceGenerator.java b/user/src/com/google/gwt/resources/rg/AbstractResourceGenerator.java
new file mode 100644
index 0000000..bec4310
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/AbstractResourceGenerator.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.resources.ext.ClientBundleFields;
+import com.google.gwt.resources.ext.ClientBundleRequirements;
+import com.google.gwt.resources.ext.ResourceContext;
+import com.google.gwt.resources.ext.ResourceGenerator;
+
+/**
+ * A base class providing common methods for ResourceGenerator implementations.
+ * 
+ * @see com.google.gwt.resources.ext.ResourceGeneratorUtil
+ */
+public abstract class AbstractResourceGenerator implements ResourceGenerator {
+  public abstract String createAssignment(TreeLogger logger,
+      ResourceContext context, JMethod method) throws UnableToCompleteException;
+
+  /**
+   * A no-op implementation.
+   */
+  public void createFields(TreeLogger logger, ResourceContext context,
+      ClientBundleFields fields) throws UnableToCompleteException {
+  }
+
+  /**
+   * A no-op implementation.
+   */
+  public void finish(TreeLogger logger, ResourceContext context)
+      throws UnableToCompleteException {
+  }
+
+  /**
+   * A no-op implementation.
+   */
+  public void init(TreeLogger logger, ResourceContext context)
+      throws UnableToCompleteException {
+  }
+
+  /**
+   * A no-op implementation.
+   */
+  public void prepare(TreeLogger logger, ResourceContext context,
+      ClientBundleRequirements requirements, JMethod method)
+      throws UnableToCompleteException {
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rg/BundleResourceGenerator.java b/user/src/com/google/gwt/resources/rg/BundleResourceGenerator.java
new file mode 100644
index 0000000..579677d
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/BundleResourceGenerator.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.resources.ext.ResourceContext;
+
+/**
+ * This is a special case of ResourceGenerator that handles nested bundles.
+ */
+public class BundleResourceGenerator extends AbstractResourceGenerator {
+
+  @Override
+  public String createAssignment(TreeLogger logger, ResourceContext context,
+      JMethod method) throws UnableToCompleteException {
+    JClassType gwtType = context.getGeneratorContext().getTypeOracle().findType(
+        GWT.class.getName());
+    assert gwtType != null;
+
+    return gwtType.getQualifiedSourceName() + ".create("
+        + method.getReturnType().getQualifiedSourceName() + ".class)";
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rg/CssResourceGenerator.java b/user/src/com/google/gwt/resources/rg/CssResourceGenerator.java
new file mode 100644
index 0000000..0a5c70b
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/CssResourceGenerator.java
@@ -0,0 +1,1614 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.BadPropertyValueException;
+import com.google.gwt.core.ext.Generator;
+import com.google.gwt.core.ext.PropertyOracle;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
+import com.google.gwt.core.ext.typeinfo.JType;
+import com.google.gwt.core.ext.typeinfo.NotFoundException;
+import com.google.gwt.core.ext.typeinfo.TypeOracle;
+import com.google.gwt.dev.util.DefaultTextOutput;
+import com.google.gwt.dev.util.Util;
+import com.google.gwt.dom.client.Element;
+import com.google.gwt.resources.client.CssResource;
+import com.google.gwt.resources.client.DataResource;
+import com.google.gwt.resources.client.ImageResource;
+import com.google.gwt.resources.client.CssResource.ClassName;
+import com.google.gwt.resources.client.CssResource.Import;
+import com.google.gwt.resources.client.CssResource.ImportedWithPrefix;
+import com.google.gwt.resources.client.CssResource.Shared;
+import com.google.gwt.resources.client.CssResource.Strict;
+import com.google.gwt.resources.client.ImageResource.ImageOptions;
+import com.google.gwt.resources.client.ImageResource.RepeatStyle;
+import com.google.gwt.resources.css.CssGenerationVisitor;
+import com.google.gwt.resources.css.GenerateCssAst;
+import com.google.gwt.resources.css.ast.CollapsedNode;
+import com.google.gwt.resources.css.ast.Context;
+import com.google.gwt.resources.css.ast.CssCompilerException;
+import com.google.gwt.resources.css.ast.CssDef;
+import com.google.gwt.resources.css.ast.CssEval;
+import com.google.gwt.resources.css.ast.CssIf;
+import com.google.gwt.resources.css.ast.CssMediaRule;
+import com.google.gwt.resources.css.ast.CssModVisitor;
+import com.google.gwt.resources.css.ast.CssNoFlip;
+import com.google.gwt.resources.css.ast.CssNode;
+import com.google.gwt.resources.css.ast.CssNodeCloner;
+import com.google.gwt.resources.css.ast.CssProperty;
+import com.google.gwt.resources.css.ast.CssRule;
+import com.google.gwt.resources.css.ast.CssSelector;
+import com.google.gwt.resources.css.ast.CssSprite;
+import com.google.gwt.resources.css.ast.CssStylesheet;
+import com.google.gwt.resources.css.ast.CssUrl;
+import com.google.gwt.resources.css.ast.CssVisitor;
+import com.google.gwt.resources.css.ast.HasNodes;
+import com.google.gwt.resources.css.ast.CssProperty.DotPathValue;
+import com.google.gwt.resources.css.ast.CssProperty.ExpressionValue;
+import com.google.gwt.resources.css.ast.CssProperty.IdentValue;
+import com.google.gwt.resources.css.ast.CssProperty.ListValue;
+import com.google.gwt.resources.css.ast.CssProperty.NumberValue;
+import com.google.gwt.resources.css.ast.CssProperty.Value;
+import com.google.gwt.resources.ext.ClientBundleRequirements;
+import com.google.gwt.resources.ext.ResourceContext;
+import com.google.gwt.resources.ext.ResourceGeneratorUtil;
+import com.google.gwt.user.rebind.SourceWriter;
+import com.google.gwt.user.rebind.StringSourceWriter;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.Adler32;
+
+/**
+ * Provides implementations of CSSResources.
+ */
+public class CssResourceGenerator extends AbstractResourceGenerator {
+  private static final String[] DEFAULT_EXTENSIONS = new String[] {".css"};
+
+  static class ClassRenamer extends CssVisitor {
+    private final Map<String, Map<JMethod, String>> classReplacementsWithPrefix;
+    private final Pattern classSelectorPattern = Pattern.compile("\\.([^ :>+#.]*)");
+    private final TreeLogger logger;
+    private final Set<JMethod> missingClasses;
+    private final Set<String> replacedClasses = new HashSet<String>();
+    private final boolean strict;
+    private final Set<String> unknownClasses = new HashSet<String>();
+
+    public ClassRenamer(TreeLogger logger,
+        Map<String, Map<JMethod, String>> classReplacementsWithPrefix,
+        boolean strict) {
+      this.logger = logger.branch(TreeLogger.DEBUG, "Replacing CSS class names");
+      this.classReplacementsWithPrefix = classReplacementsWithPrefix;
+      this.strict = strict;
+
+      // Require a definition for all classes in the default namespace
+      assert classReplacementsWithPrefix.containsKey("");
+      missingClasses = new HashSet<JMethod>(
+          classReplacementsWithPrefix.get("").keySet());
+    }
+
+    @Override
+    public void endVisit(CssSelector x, Context ctx) {
+      String sel = x.getSelector();
+
+      // TODO This would be simplified by having a class hierarchy for selectors
+      for (Map.Entry<String, Map<JMethod, String>> outerEntry : classReplacementsWithPrefix.entrySet()) {
+        String prefix = outerEntry.getKey();
+        for (Map.Entry<JMethod, String> entry : outerEntry.getValue().entrySet()) {
+          String name = entry.getKey().getName();
+
+          ClassName className = entry.getKey().getAnnotation(ClassName.class);
+          if (className != null) {
+            name = className.value();
+          }
+          name = prefix + name;
+
+          Pattern p = Pattern.compile("(.*)\\.(" + Pattern.quote(name)
+              + ")([ :>+#.].*|$)");
+          Matcher m = p.matcher(sel);
+          if (m.find()) {
+            sel = m.group(1) + "." + entry.getValue() + m.group(3);
+            missingClasses.remove(entry.getKey());
+            if (strict) {
+              replacedClasses.add(entry.getValue());
+            }
+          }
+        }
+      }
+
+      sel = sel.trim();
+
+      if (strict) {
+        Matcher m = classSelectorPattern.matcher(sel);
+        while (m.find()) {
+          String classSelector = m.group(1);
+          if (!replacedClasses.contains(classSelector)) {
+            unknownClasses.add(classSelector);
+          }
+        }
+      }
+
+      x.setSelector(sel);
+    }
+
+    @Override
+    public void endVisit(CssStylesheet x, Context ctx) {
+      boolean stop = false;
+      if (!missingClasses.isEmpty()) {
+        stop = true;
+        TreeLogger errorLogger = logger.branch(TreeLogger.INFO,
+            "The following obfuscated style classes were missing from "
+                + "the source CSS file:");
+        for (JMethod m : missingClasses) {
+          String name = m.getName();
+          ClassName className = m.getAnnotation(ClassName.class);
+          if (className != null) {
+            name = className.value();
+          }
+          errorLogger.log(TreeLogger.ERROR, name + ": Fix by adding ." + name
+              + "{}");
+        }
+      }
+
+      if (strict && !unknownClasses.isEmpty()) {
+        stop = true;
+        TreeLogger errorLogger = logger.branch(TreeLogger.ERROR,
+            "The following unobfuscated classes were present in a strict CssResource:");
+        for (String s : unknownClasses) {
+          errorLogger.log(TreeLogger.ERROR, s);
+        }
+      }
+
+      if (stop) {
+        throw new CssCompilerException("Missing a CSS replacement");
+      }
+    }
+  }
+
+  /**
+   * Statically evaluates {@literal @if} rules.
+   */
+  static class IfEvaluator extends CssModVisitor {
+    private final TreeLogger logger;
+    private final PropertyOracle oracle;
+
+    public IfEvaluator(TreeLogger logger, PropertyOracle oracle) {
+      this.logger = logger.branch(TreeLogger.DEBUG,
+          "Replacing property-based @if blocks");
+      this.oracle = oracle;
+    }
+
+    @Override
+    public void endVisit(CssIf x, Context ctx) {
+      if (x.getExpression() != null) {
+        // This gets taken care of by the runtime substitution visitor
+      } else {
+        try {
+          String propertyName = x.getPropertyName();
+          String propValue = oracle.getPropertyValue(logger, propertyName);
+
+          /*
+           * If the deferred binding property's value is in the list of values
+           * in the @if rule, move the rules into the @if's context.
+           */
+          if (Arrays.asList(x.getPropertyValues()).contains(propValue)
+              ^ x.isNegated()) {
+            for (CssNode n : x.getNodes()) {
+              ctx.insertBefore(n);
+            }
+          } else {
+            // Otherwise, move the else block into the if statement's position
+            for (CssNode n : x.getElseNodes()) {
+              ctx.insertBefore(n);
+            }
+          }
+
+          // Always delete @if rules that we can statically evaluate
+          ctx.removeMe();
+        } catch (BadPropertyValueException e) {
+          logger.log(TreeLogger.ERROR, "Unable to evaluate @if block", e);
+          throw new CssCompilerException("Unable to parse CSS", e);
+        }
+      }
+    }
+  }
+
+  static class JClassOrderComparator implements Comparator<JClassType> {
+    public int compare(JClassType o1, JClassType o2) {
+      return o1.getQualifiedSourceName().compareTo(o2.getQualifiedSourceName());
+    }
+  }
+
+  /**
+   * Merges rules that have matching selectors.
+   */
+  static class MergeIdenticalSelectorsVisitor extends CssModVisitor {
+    private final Map<String, CssRule> canonicalRules = new HashMap<String, CssRule>();
+    private final List<CssRule> rulesInOrder = new ArrayList<CssRule>();
+
+    @Override
+    public boolean visit(CssIf x, Context ctx) {
+      visitInNewContext(x.getNodes());
+      visitInNewContext(x.getElseNodes());
+      return false;
+    }
+
+    @Override
+    public boolean visit(CssMediaRule x, Context ctx) {
+      visitInNewContext(x.getNodes());
+      return false;
+    }
+
+    @Override
+    public boolean visit(CssRule x, Context ctx) {
+      // Assumed to run immediately after SplitRulesVisitor
+      assert x.getSelectors().size() == 1;
+      CssSelector sel = x.getSelectors().get(0);
+
+      if (canonicalRules.containsKey(sel.getSelector())) {
+        CssRule canonical = canonicalRules.get(sel.getSelector());
+
+        // Check everything between the canonical rule and this rule for common
+        // properties. If there are common properties, it would be unsafe to
+        // promote the rule.
+        boolean hasCommon = false;
+        int index = rulesInOrder.indexOf(canonical) + 1;
+        assert index != 0;
+
+        for (Iterator<CssRule> i = rulesInOrder.listIterator(index); i.hasNext()
+            && !hasCommon;) {
+          hasCommon = haveCommonProperties(i.next(), x);
+        }
+
+        if (!hasCommon) {
+          // It's safe to promote the rule
+          canonical.getProperties().addAll(x.getProperties());
+          ctx.removeMe();
+          return false;
+        }
+      }
+
+      canonicalRules.put(sel.getSelector(), x);
+      rulesInOrder.add(x);
+      return false;
+    }
+
+    private void visitInNewContext(List<CssNode> nodes) {
+      MergeIdenticalSelectorsVisitor v = new MergeIdenticalSelectorsVisitor();
+      v.accept(nodes);
+      rulesInOrder.addAll(v.rulesInOrder);
+    }
+  }
+
+  /**
+   * Merges rules that have identical content.
+   */
+  static class MergeRulesByContentVisitor extends CssModVisitor {
+    private Map<String, CssRule> rulesByContents = new HashMap<String, CssRule>();
+    private final List<CssRule> rulesInOrder = new ArrayList<CssRule>();
+
+    @Override
+    public boolean visit(CssIf x, Context ctx) {
+      visitInNewContext(x.getNodes());
+      visitInNewContext(x.getElseNodes());
+      return false;
+    }
+
+    @Override
+    public boolean visit(CssMediaRule x, Context ctx) {
+      visitInNewContext(x.getNodes());
+      return false;
+    }
+
+    @Override
+    public boolean visit(CssRule x, Context ctx) {
+      StringBuilder b = new StringBuilder();
+      for (CssProperty p : x.getProperties()) {
+        b.append(p.getName()).append(":").append(p.getValues().getExpression());
+      }
+
+      String content = b.toString();
+      CssRule canonical = rulesByContents.get(content);
+
+      // Check everything between the canonical rule and this rule for common
+      // properties. If there are common properties, it would be unsafe to
+      // promote the rule.
+      if (canonical != null) {
+        boolean hasCommon = false;
+        int index = rulesInOrder.indexOf(canonical) + 1;
+        assert index != 0;
+
+        for (Iterator<CssRule> i = rulesInOrder.listIterator(index); i.hasNext()
+            && !hasCommon;) {
+          hasCommon = haveCommonProperties(i.next(), x);
+        }
+
+        if (!hasCommon) {
+          canonical.getSelectors().addAll(x.getSelectors());
+          ctx.removeMe();
+          return false;
+        }
+      }
+
+      rulesByContents.put(content, x);
+      rulesInOrder.add(x);
+      return false;
+    }
+
+    private void visitInNewContext(List<CssNode> nodes) {
+      MergeRulesByContentVisitor v = new MergeRulesByContentVisitor();
+      v.accept(nodes);
+      rulesInOrder.addAll(v.rulesInOrder);
+    }
+  }
+
+  static class RequirementsCollector extends CssVisitor {
+    private final TreeLogger logger;
+    private final ClientBundleRequirements requirements;
+
+    public RequirementsCollector(TreeLogger logger,
+        ClientBundleRequirements requirements) {
+      this.logger = logger.branch(TreeLogger.DEBUG,
+          "Scanning CSS for requirements");
+      this.requirements = requirements;
+    }
+
+    @Override
+    public void endVisit(CssIf x, Context ctx) {
+      String propertyName = x.getPropertyName();
+      if (propertyName != null) {
+        try {
+          requirements.addPermutationAxis(propertyName);
+        } catch (BadPropertyValueException e) {
+          logger.log(TreeLogger.ERROR, "Unknown deferred-binding property "
+              + propertyName, e);
+          throw new CssCompilerException("Unknown deferred-binding property", e);
+        }
+      }
+    }
+  }
+
+  static class RtlVisitor extends CssModVisitor {
+    /**
+     * Records if we're currently visiting a CssRule whose only selector is
+     * "body".
+     */
+    private boolean inBodyRule;
+
+    @Override
+    public void endVisit(CssProperty x, Context ctx) {
+      String name = x.getName();
+
+      if (name.equalsIgnoreCase("left")) {
+        x.setName("right");
+      } else if (name.equalsIgnoreCase("right")) {
+        x.setName("left");
+      } else if (name.endsWith("-left")) {
+        int len = name.length();
+        x.setName(name.substring(0, len - 4) + "right");
+      } else if (name.endsWith("-right")) {
+        int len = name.length();
+        x.setName(name.substring(0, len - 5) + "left");
+      } else if (name.contains("-right-")) {
+        x.setName(name.replace("-right-", "-left-"));
+      } else if (name.contains("-left-")) {
+        x.setName(name.replace("-left-", "-right-"));
+      } else {
+        List<Value> values = new ArrayList<Value>(x.getValues().getValues());
+        invokePropertyHandler(x.getName(), values);
+        x.setValue(new CssProperty.ListValue(values));
+      }
+    }
+
+    @Override
+    public boolean visit(CssNoFlip x, Context ctx) {
+      return false;
+    }
+
+    @Override
+    public boolean visit(CssRule x, Context ctx) {
+      inBodyRule = x.getSelectors().size() == 1
+          && x.getSelectors().get(0).getSelector().equals("body");
+      return true;
+    }
+
+    void propertyHandlerBackground(List<Value> values) {
+      /*
+       * The first numeric value will be treated as the left position only if we
+       * havn't seen any value that could potentially be the left value.
+       */
+      boolean seenLeft = false;
+
+      for (ListIterator<Value> it = values.listIterator(); it.hasNext();) {
+        Value v = it.next();
+        Value maybeFlipped = flipLeftRightIdentValue(v);
+        NumberValue nv = v.isNumberValue();
+        if (v != maybeFlipped) {
+          it.set(maybeFlipped);
+          seenLeft = true;
+
+        } else if (isIdent(v, "center")) {
+          seenLeft = true;
+
+        } else if (!seenLeft && (nv != null)) {
+          seenLeft = true;
+          if ("%".equals(nv.getUnits())) {
+            float position = 100f - nv.getValue();
+            it.set(new NumberValue(position, "%"));
+            break;
+          }
+        }
+      }
+    }
+
+    void propertyHandlerBackgroundPosition(List<Value> values) {
+      propertyHandlerBackground(values);
+    }
+
+    Value propertyHandlerBackgroundPositionX(Value v) {
+      ArrayList<Value> list = new ArrayList<Value>(1);
+      list.add(v);
+      propertyHandlerBackground(list);
+      return list.get(0);
+    }
+
+    /**
+     * Note there should be no propertyHandlerBorder(). The CSS spec states that
+     * the border property must set all values at once.
+     */
+    void propertyHandlerBorderColor(List<Value> values) {
+      swapFour(values);
+    }
+
+    void propertyHandlerBorderStyle(List<Value> values) {
+      swapFour(values);
+    }
+
+    void propertyHandlerBorderWidth(List<Value> values) {
+      swapFour(values);
+    }
+
+    Value propertyHandlerClear(Value v) {
+      return propertyHandlerFloat(v);
+    }
+
+    Value propertyHandlerCursor(Value v) {
+      IdentValue identValue = v.isIdentValue();
+      if (identValue == null) {
+        return v;
+      }
+
+      String ident = identValue.getIdent().toLowerCase();
+      if (!ident.endsWith("-resize")) {
+        return v;
+      }
+
+      StringBuffer newIdent = new StringBuffer();
+
+      if (ident.length() == 9) {
+        if (ident.charAt(0) == 'n') {
+          newIdent.append('n');
+          ident = ident.substring(1);
+        } else if (ident.charAt(0) == 's') {
+          newIdent.append('s');
+          ident = ident.substring(1);
+        } else {
+          return v;
+        }
+      }
+
+      if (ident.length() == 8) {
+        if (ident.charAt(0) == 'e') {
+          newIdent.append("w-resize");
+        } else if (ident.charAt(0) == 'w') {
+          newIdent.append("e-resize");
+        } else {
+          return v;
+        }
+        return new IdentValue(newIdent.toString());
+      } else {
+        return v;
+      }
+    }
+
+    Value propertyHandlerDirection(Value v) {
+      if (inBodyRule) {
+        if (isIdent(v, "ltr")) {
+          return new IdentValue("rtl");
+        } else if (isIdent(v, "rtl")) {
+          return new IdentValue("ltr");
+        }
+      }
+      return v;
+    }
+
+    Value propertyHandlerFloat(Value v) {
+      return flipLeftRightIdentValue(v);
+    }
+
+    void propertyHandlerMargin(List<Value> values) {
+      swapFour(values);
+    }
+
+    void propertyHandlerPadding(List<Value> values) {
+      swapFour(values);
+    }
+
+    Value propertyHandlerPageBreakAfter(Value v) {
+      return flipLeftRightIdentValue(v);
+    }
+
+    Value propertyHandlerPageBreakBefore(Value v) {
+      return flipLeftRightIdentValue(v);
+    }
+
+    Value propertyHandlerTextAlign(Value v) {
+      return flipLeftRightIdentValue(v);
+    }
+
+    private Value flipLeftRightIdentValue(Value v) {
+      if (isIdent(v, "right")) {
+        return new IdentValue("left");
+
+      } else if (isIdent(v, "left")) {
+        return new IdentValue("right");
+      }
+      return v;
+    }
+
+    /**
+     * Reflectively invokes a propertyHandler method for the named property.
+     * Dashed names are transformed into camel-case names; only letters
+     * following a dash will be capitalized when looking for a method to prevent
+     * <code>fooBar<code> and <code>foo-bar</code> from colliding.
+     */
+    private void invokePropertyHandler(String name, List<Value> values) {
+      // See if we have a property-handler function
+      try {
+        String[] parts = name.toLowerCase().split("-");
+        StringBuffer methodName = new StringBuffer("propertyHandler");
+        for (String part : parts) {
+          methodName.append(Character.toUpperCase(part.charAt(0)));
+          methodName.append(part, 1, part.length());
+        }
+
+        try {
+          // Single-arg for simplicity
+          Method m = getClass().getDeclaredMethod(methodName.toString(),
+              Value.class);
+          assert Value.class.isAssignableFrom(m.getReturnType());
+          Value newValue = (Value) m.invoke(this, values.get(0));
+          values.set(0, newValue);
+        } catch (NoSuchMethodException e) {
+          // OK
+        }
+
+        try {
+          // Or the whole List for completeness
+          Method m = getClass().getDeclaredMethod(methodName.toString(),
+              List.class);
+          m.invoke(this, values);
+        } catch (NoSuchMethodException e) {
+          // OK
+        }
+
+      } catch (SecurityException e) {
+        throw new CssCompilerException(
+            "Unable to invoke property handler function for " + name, e);
+      } catch (IllegalArgumentException e) {
+        throw new CssCompilerException(
+            "Unable to invoke property handler function for " + name, e);
+      } catch (IllegalAccessException e) {
+        throw new CssCompilerException(
+            "Unable to invoke property handler function for " + name, e);
+      } catch (InvocationTargetException e) {
+        throw new CssCompilerException(
+            "Unable to invoke property handler function for " + name, e);
+      }
+    }
+
+    private boolean isIdent(Value value, String query) {
+      IdentValue v = value.isIdentValue();
+      return v != null && v.getIdent().equalsIgnoreCase(query);
+    }
+
+    /**
+     * Swaps the second and fourth values in a list of four values.
+     */
+    private void swapFour(List<Value> values) {
+      if (values.size() == 4) {
+        Collections.swap(values, 1, 3);
+      }
+    }
+  }
+
+  /**
+   * Splits rules with compound selectors into multiple rules.
+   */
+  static class SplitRulesVisitor extends CssModVisitor {
+    @Override
+    public void endVisit(CssRule x, Context ctx) {
+      if (x.getSelectors().size() == 1) {
+        return;
+      }
+
+      for (CssSelector sel : x.getSelectors()) {
+        CssRule newRule = new CssRule();
+        newRule.getSelectors().add(sel);
+        newRule.getProperties().addAll(
+            CssNodeCloner.clone(CssProperty.class, x.getProperties()));
+        ctx.insertBefore(newRule);
+      }
+      ctx.removeMe();
+      return;
+    }
+  }
+
+  /**
+   * Replaces CssSprite nodes with CssRule nodes that will display the sprited
+   * image. The real trick with spriting the images is to reuse the
+   * ImageResource processing framework by requiring the sprite to be defined in
+   * terms of an ImageResource.
+   */
+  static class Spriter extends CssModVisitor {
+    private final ResourceContext context;
+    private final TreeLogger logger;
+
+    public Spriter(TreeLogger logger, ResourceContext context) {
+      this.logger = logger.branch(TreeLogger.DEBUG,
+          "Creating image sprite classes");
+      this.context = context;
+    }
+
+    @Override
+    public void endVisit(CssSprite x, Context ctx) {
+      JClassType bundleType = context.getClientBundleType();
+      String functionName = x.getResourceFunction();
+
+      if (functionName == null) {
+        logger.log(TreeLogger.ERROR, "The @sprite rule " + x.getSelectors()
+            + " must specify the " + CssSprite.IMAGE_PROPERTY_NAME
+            + " property");
+        throw new CssCompilerException("No image property specified");
+      }
+
+      // Find the image accessor method
+      JMethod imageMethod = null;
+      JMethod[] allMethods = bundleType.getOverridableMethods();
+      for (int i = 0; imageMethod == null && i < allMethods.length; i++) {
+        JMethod candidate = allMethods[i];
+        // If the function name matches and takes no parameters
+        if (candidate.getName().equals(functionName)
+            && candidate.getParameters().length == 0) {
+          // We have a match
+          imageMethod = candidate;
+        }
+      }
+
+      // Method unable to be located
+      if (imageMethod == null) {
+        logger.log(TreeLogger.ERROR, "Unable to find ImageResource method "
+            + functionName + " in " + bundleType.getQualifiedSourceName());
+        throw new CssCompilerException("Cannot find image function");
+      }
+
+      JClassType imageResourceType = context.getGeneratorContext().getTypeOracle().findType(
+          ImageResource.class.getName());
+      assert imageResourceType != null;
+
+      if (!imageResourceType.isAssignableFrom(imageMethod.getReturnType().isClassOrInterface())) {
+        logger.log(TreeLogger.ERROR, "The return type of " + functionName
+            + " is not assignable to "
+            + imageResourceType.getSimpleSourceName());
+        throw new CssCompilerException("Incorrect return type for "
+            + CssSprite.IMAGE_PROPERTY_NAME + " method");
+      }
+
+      ImageOptions options = imageMethod.getAnnotation(ImageOptions.class);
+      RepeatStyle repeatStyle;
+      if (options != null) {
+        repeatStyle = options.repeatStyle();
+      } else {
+        repeatStyle = RepeatStyle.None;
+      }
+
+      String instance = "(" + context.getImplementationSimpleSourceName()
+          + ".this." + functionName + "())";
+
+      CssRule replacement = new CssRule();
+      replacement.getSelectors().addAll(x.getSelectors());
+      List<CssProperty> properties = replacement.getProperties();
+
+      if (repeatStyle == RepeatStyle.None
+          || repeatStyle == RepeatStyle.Horizontal) {
+        properties.add(new CssProperty("height", new ExpressionValue(instance
+            + ".getHeight() + \"px\""), false));
+      }
+
+      if (repeatStyle == RepeatStyle.None
+          || repeatStyle == RepeatStyle.Vertical) {
+        properties.add(new CssProperty("width", new ExpressionValue(instance
+            + ".getWidth() + \"px\""), false));
+      }
+      properties.add(new CssProperty("overflow", new IdentValue("hidden"),
+          false));
+
+      String repeatText;
+      switch (repeatStyle) {
+        case None:
+          repeatText = " no-repeat";
+          break;
+        case Horizontal:
+          repeatText = " repeat-x";
+          break;
+        case Vertical:
+          repeatText = " repeat-y";
+          break;
+        case Both:
+          repeatText = " repeat";
+          break;
+        default:
+          throw new RuntimeException("Unknown repeatStyle " + repeatStyle);
+      }
+
+      String backgroundExpression = "\"url(\\\"\" + " + instance
+          + ".getURL() + \"\\\") -\" + " + instance
+          + ".getLeft() + \"px -\" + " + instance + ".getTop() + \"px "
+          + repeatText + "\"";
+      properties.add(new CssProperty("background", new ExpressionValue(
+          backgroundExpression), false));
+
+      // Retain any user-specified properties
+      properties.addAll(x.getProperties());
+
+      ctx.replaceMe(replacement);
+    }
+  }
+
+  static class SubstitutionCollector extends CssVisitor {
+    private final Map<String, CssDef> substitutions = new HashMap<String, CssDef>();
+
+    @Override
+    public void endVisit(CssDef x, Context ctx) {
+      substitutions.put(x.getKey(), x);
+    }
+
+    @Override
+    public void endVisit(CssEval x, Context ctx) {
+      substitutions.put(x.getKey(), x);
+    }
+
+    @Override
+    public void endVisit(CssUrl x, Context ctx) {
+      substitutions.put(x.getKey(), x);
+    }
+  }
+
+  /**
+   * Substitute symbolic replacements into string values.
+   */
+  static class SubstitutionReplacer extends CssVisitor {
+    private final ResourceContext context;
+    private final TreeLogger logger;
+    private final Map<String, CssDef> substitutions;
+
+    public SubstitutionReplacer(TreeLogger logger, ResourceContext context,
+        Map<String, CssDef> substitutions) {
+      this.context = context;
+      this.logger = logger;
+      this.substitutions = substitutions;
+    }
+
+    @Override
+    public void endVisit(CssProperty x, Context ctx) {
+      if (x.getValues() == null) {
+        // Nothing to do
+        return;
+      }
+
+      List<Value> values = new ArrayList<Value>(x.getValues().getValues());
+
+      for (ListIterator<Value> i = values.listIterator(); i.hasNext();) {
+        IdentValue v = i.next().isIdentValue();
+
+        if (v == null) {
+          // Don't try to substitute into anything other than idents
+          continue;
+        }
+
+        String value = v.getIdent();
+        CssDef def = substitutions.get(value);
+
+        if (def == null) {
+          continue;
+        } else if (def instanceof CssUrl) {
+          assert def.getValues().size() == 1;
+          assert def.getValues().get(0).isIdentValue() != null;
+          String functionName = def.getValues().get(0).isIdentValue().getIdent();
+
+          // Find the method
+          JMethod method = context.getClientBundleType().findMethod(
+              functionName, new JType[0]);
+
+          if (method == null) {
+            logger.log(TreeLogger.ERROR, "Unable to find DataResource method "
+                + functionName + " in "
+                + context.getClientBundleType().getQualifiedSourceName());
+            throw new CssCompilerException("Cannot find data function");
+          }
+
+          String instance = "((" + DataResource.class.getName() + ")("
+              + context.getImplementationSimpleSourceName() + ".this."
+              + functionName + "()))";
+
+          StringBuilder expression = new StringBuilder();
+          expression.append("\"url('\" + ");
+          expression.append(instance).append(".getUrl()");
+          expression.append(" + \"')\"");
+          i.set(new ExpressionValue(expression.toString()));
+
+        } else {
+          i.remove();
+          for (Value defValue : def.getValues()) {
+            i.add(defValue);
+          }
+        }
+      }
+
+      x.setValue(new ListValue(values));
+    }
+  }
+
+  /**
+   * A lookup table of base-32 chars we use to encode CSS idents. Because CSS
+   * class selectors may be case-insensitive, we don't have enough characters to
+   * use a base-64 encoding.
+   */
+  private static final char[] BASE32_CHARS = new char[] {
+      'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+      'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '-', '0',
+      '1', '2', '3', '4'};
+
+  /**
+   * This value is used by {@link #concatOp} to help create a more balanced AST
+   * tree by producing parenthetical expressions.
+   */
+  private static final int CONCAT_EXPRESSION_LIMIT = 20;
+
+  public static void main(String[] args) {
+    for (int i = 0; i < 1000; i++) {
+      System.out.println(makeIdent(i));
+    }
+  }
+
+  static boolean haveCommonProperties(CssRule a, CssRule b) {
+    if (a.getProperties().size() == 0 || b.getProperties().size() == 0) {
+      return false;
+    }
+
+    SortedSet<String> aProperties = new TreeSet<String>();
+    SortedSet<String> bProperties = new TreeSet<String>();
+
+    for (CssProperty p : a.getProperties()) {
+      aProperties.add(p.getName());
+    }
+    for (CssProperty p : b.getProperties()) {
+      bProperties.add(p.getName());
+    }
+
+    Iterator<String> ai = aProperties.iterator();
+    Iterator<String> bi = bProperties.iterator();
+
+    String aName = ai.next();
+    String bName = bi.next();
+    for (;;) {
+      int comp = aName.compareToIgnoreCase(bName);
+      if (comp == 0) {
+        return true;
+      } else if (comp > 0) {
+        if (aName.startsWith(bName + "-")) {
+          return true;
+        }
+
+        if (!bi.hasNext()) {
+          break;
+        }
+        bName = bi.next();
+      } else {
+        if (bName.startsWith(aName + "-")) {
+          return true;
+        }
+        if (!ai.hasNext()) {
+          break;
+        }
+        aName = ai.next();
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Create a Java expression that evaluates to a string representation of the
+   * given node. Visible only for testing.
+   */
+  static <T extends CssNode & HasNodes> String makeExpression(
+      TreeLogger logger, ResourceContext context, JClassType cssResourceType,
+      T node, boolean prettyOutput) throws UnableToCompleteException {
+    // Generate the CSS template
+    DefaultTextOutput out = new DefaultTextOutput(!prettyOutput);
+    CssGenerationVisitor v = new CssGenerationVisitor(out);
+    v.accept(node);
+
+    // Generate the final Java expression
+    String template = out.toString();
+    StringBuilder b = new StringBuilder();
+    int start = 0;
+
+    /*
+     * Very large concatenation expressions using '+' cause the GWT compiler to
+     * overflow the stack due to deep AST nesting. The workaround for now is to
+     * force it to be more balanced using intermediate concatenation groupings.
+     * 
+     * This variable is used to track the number of subexpressions within the
+     * current parenthetical expression.
+     */
+    int numExpressions = 0;
+
+    b.append('(');
+    for (Map.Entry<Integer, List<CssNode>> entry : v.getSubstitutionPositions().entrySet()) {
+      // Add the static section between start and the substitution point
+      b.append('"');
+      b.append(Generator.escape(template.substring(start, entry.getKey())));
+      b.append('\"');
+      numExpressions = concatOp(numExpressions, b);
+
+      // Add the nodes at the substitution point
+      for (CssNode x : entry.getValue()) {
+        TreeLogger loopLogger = logger.branch(TreeLogger.DEBUG,
+            "Performing substitution in node " + x.toString());
+
+        if (x instanceof CssIf) {
+          CssIf asIf = (CssIf) x;
+
+          // Generate the sub-expressions
+          String expression = makeExpression(loopLogger, context,
+              cssResourceType, new CollapsedNode(asIf), prettyOutput);
+
+          String elseExpression;
+          if (asIf.getElseNodes().isEmpty()) {
+            // We'll treat an empty else block as an empty string
+            elseExpression = "\"\"";
+          } else {
+            elseExpression = makeExpression(loopLogger, context,
+                cssResourceType, new CollapsedNode(asIf.getElseNodes()),
+                prettyOutput);
+          }
+
+          // ((expr) ? "CSS" : "elseCSS") +
+          b.append("((" + asIf.getExpression() + ") ? " + expression + " : "
+              + elseExpression + ") ");
+          numExpressions = concatOp(numExpressions, b);
+
+        } else if (x instanceof CssProperty) {
+          CssProperty property = (CssProperty) x;
+
+          validateValue(loopLogger, context.getClientBundleType(),
+              property.getValues());
+
+          // (expr) +
+          b.append("(" + property.getValues().getExpression() + ") ");
+          numExpressions = concatOp(numExpressions, b);
+
+        } else {
+          // This indicates that some magic node is slipping by our visitors
+          loopLogger.log(TreeLogger.ERROR, "Unhandled substitution "
+              + x.getClass());
+          throw new UnableToCompleteException();
+        }
+      }
+      start = entry.getKey();
+    }
+
+    // Add the remaining parts of the template
+    b.append('"');
+    b.append(Generator.escape(template.substring(start)));
+    b.append('"');
+    b.append(')');
+
+    return b.toString();
+  }
+
+  /**
+   * Check if number of concat expressions currently exceeds limit and either
+   * append '+' if the limit isn't reached or ') + (' if it is.
+   * 
+   * @return numExpressions + 1 or 0 if limit was exceeded.
+   */
+  private static int concatOp(int numExpressions, StringBuilder b) {
+    /*
+     * TODO: Fix the compiler to better handle arbitrarily long concatenation
+     * expressions.
+     */
+    if (numExpressions >= CONCAT_EXPRESSION_LIMIT) {
+      b.append(") + (");
+      return 0;
+    }
+
+    b.append(" + ");
+    return numExpressions + 1;
+  }
+
+  private static String makeIdent(long id) {
+    assert id >= 0;
+
+    StringBuilder b = new StringBuilder();
+
+    // Use only guaranteed-alpha characters for the first character
+    b.append(BASE32_CHARS[(int) (id & 0xf)]);
+    id >>= 4;
+
+    while (id != 0) {
+      b.append(BASE32_CHARS[(int) (id & 0x1f)]);
+      id >>= 5;
+    }
+
+    return b.toString();
+  }
+
+  /**
+   * This function validates any context-sensitive Values.
+   */
+  private static void validateValue(TreeLogger logger,
+      JClassType resourceBundleType, Value value)
+      throws UnableToCompleteException {
+
+    ListValue list = value.isListValue();
+    if (list != null) {
+      for (Value v : list.getValues()) {
+        validateValue(logger, resourceBundleType, v);
+      }
+      return;
+    }
+
+    DotPathValue dot = value.isDotPathValue();
+    if (dot != null) {
+      String[] elements = dot.getPath().split("\\.");
+      if (elements.length == 0) {
+        logger.log(TreeLogger.ERROR, "value() functions must specify a path");
+        throw new UnableToCompleteException();
+      }
+
+      JType currentType = resourceBundleType;
+      for (Iterator<String> i = Arrays.asList(elements).iterator(); i.hasNext();) {
+        String pathElement = i.next();
+
+        JClassType referenceType = currentType.isClassOrInterface();
+        if (referenceType == null) {
+          logger.log(TreeLogger.ERROR, "Cannot resolve member " + pathElement
+              + " on non-reference type "
+              + currentType.getQualifiedSourceName());
+          throw new UnableToCompleteException();
+        }
+
+        try {
+          JMethod m = referenceType.getMethod(pathElement, new JType[0]);
+          currentType = m.getReturnType();
+        } catch (NotFoundException e) {
+          logger.log(TreeLogger.ERROR, "Could not find no-arg method named "
+              + pathElement + " in type "
+              + currentType.getQualifiedSourceName());
+          throw new UnableToCompleteException();
+        }
+      }
+      return;
+    }
+  }
+
+  private String classPrefix;
+  private JClassType cssResourceType;
+  private JClassType elementType;
+  private boolean enableMerge;
+  private boolean prettyOutput;
+  private Map<JClassType, Map<JMethod, String>> replacementsByClassAndMethod;
+
+  private Map<JMethod, String> replacementsForSharedMethods;
+
+  private Map<JMethod, CssStylesheet> stylesheetMap;
+
+  private JClassType stringType;
+
+  @Override
+  public String createAssignment(TreeLogger logger, ResourceContext context,
+      JMethod method) throws UnableToCompleteException {
+
+    SourceWriter sw = new StringSourceWriter();
+    // Write the expression to create the subtype.
+    sw.println("new " + method.getReturnType().getQualifiedSourceName()
+        + "() {");
+    sw.indent();
+
+    JClassType cssResourceSubtype = method.getReturnType().isInterface();
+    assert cssResourceSubtype != null;
+    Map<String, Map<JMethod, String>> replacementsWithPrefix = new HashMap<String, Map<JMethod, String>>();
+
+    replacementsWithPrefix.put("",
+        computeReplacementsForType(cssResourceSubtype));
+    Import imp = method.getAnnotation(Import.class);
+    if (imp != null) {
+      boolean fail = false;
+      for (Class<? extends CssResource> clazz : imp.value()) {
+        JClassType importType = context.getGeneratorContext().getTypeOracle().findType(
+            clazz.getName().replace('$', '.'));
+        String prefix = importType.getSimpleSourceName();
+        ImportedWithPrefix exp = importType.getAnnotation(ImportedWithPrefix.class);
+        if (exp != null) {
+          prefix = exp.value();
+        }
+        assert importType != null;
+
+        if (replacementsWithPrefix.put(prefix + "-",
+            computeReplacementsForType(importType)) != null) {
+          logger.log(TreeLogger.ERROR,
+              "Multiple imports that would use the prefix " + prefix);
+          fail = true;
+        }
+      }
+      if (fail) {
+        throw new UnableToCompleteException();
+      }
+    }
+
+    /*
+     * getOverridableMethods is used to handle CssResources extending
+     * non-CssResource types. See the discussion in computeReplacementsForType.
+     */
+    for (JMethod toImplement : cssResourceSubtype.getOverridableMethods()) {
+      String name = toImplement.getName();
+      if ("getName".equals(name) || "getText".equals(name)) {
+        continue;
+      }
+
+      if (toImplement.getReturnType().equals(stringType)
+          && toImplement.getParameters().length == 0) {
+        writeClassAssignment(sw, toImplement, replacementsWithPrefix.get(""));
+
+      } else if (toImplement.getReturnType().isPrimitive() != null
+          && toImplement.getParameters().length == 0) {
+        writeDefAssignment(logger, sw, toImplement, stylesheetMap.get(method));
+
+      } else {
+        logger.log(TreeLogger.ERROR, "Don't know how to implement method "
+            + toImplement.getName());
+        throw new UnableToCompleteException();
+      }
+    }
+
+    sw.println("public String getText() {");
+    sw.indent();
+
+    boolean strict = method.getAnnotation(Strict.class) != null;
+    if (!strict) {
+      /*
+       * The developer may choose to force strict behavior onto the system. If
+       * the method does already have the @Strict annotation, print a warning.
+       */
+      try {
+        PropertyOracle propertyOracle = context.getGeneratorContext().getPropertyOracle();
+        String propertyValue = propertyOracle.getPropertyValue(logger,
+            "CssResource.strictAccessors");
+        if (Boolean.valueOf(propertyValue)) {
+          logger.log(TreeLogger.WARN, "CssResource.forceStrict is true, but "
+              + method.getName() + "() is missing the @Strict annotation.");
+          strict = true;
+        }
+      } catch (BadPropertyValueException e) {
+        // Ignore
+      }
+    }
+
+    String cssExpression = makeExpression(logger, context, cssResourceSubtype,
+        stylesheetMap.get(method), replacementsWithPrefix, strict);
+    sw.println("return " + cssExpression + ";");
+    sw.outdent();
+    sw.println("}");
+
+    sw.println("public String getName() {");
+    sw.indent();
+    sw.println("return \"" + method.getName() + "\";");
+    sw.outdent();
+    sw.println("}");
+
+    sw.outdent();
+    sw.println("}");
+
+    return sw.toString();
+  }
+
+  @Override
+  public void init(TreeLogger logger, ResourceContext context)
+      throws UnableToCompleteException {
+    try {
+      PropertyOracle propertyOracle = context.getGeneratorContext().getPropertyOracle();
+      String style = propertyOracle.getPropertyValue(logger,
+          "CssResource.style").toLowerCase();
+      prettyOutput = style.equals("pretty");
+
+      String merge = propertyOracle.getPropertyValue(logger,
+          "CssResource.mergeEnabled").toLowerCase();
+      enableMerge = merge.equals("true");
+
+      classPrefix = propertyOracle.getPropertyValue(logger,
+          "CssResource.obfuscationPrefix");
+    } catch (BadPropertyValueException e) {
+      logger.log(TreeLogger.WARN, "Unable to query module property", e);
+      throw new UnableToCompleteException();
+    }
+
+    if ("default".equals(classPrefix)) {
+      // Compute it later in computeObfuscatedNames();
+      classPrefix = null;
+    } else if ("empty".equals(classPrefix)) {
+      classPrefix = "";
+    }
+
+    // Find all of the types that we care about in the type system
+    TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle();
+
+    cssResourceType = typeOracle.findType(CssResource.class.getName());
+    assert cssResourceType != null;
+
+    elementType = typeOracle.findType(Element.class.getName());
+    assert elementType != null;
+
+    stringType = typeOracle.findType(String.class.getName());
+    assert stringType != null;
+
+    replacementsByClassAndMethod = new IdentityHashMap<JClassType, Map<JMethod, String>>();
+    replacementsForSharedMethods = new IdentityHashMap<JMethod, String>();
+    stylesheetMap = new IdentityHashMap<JMethod, CssStylesheet>();
+
+    computeObfuscatedNames(logger);
+  }
+
+  @Override
+  public void prepare(TreeLogger logger, ResourceContext context,
+      ClientBundleRequirements requirements, JMethod method)
+      throws UnableToCompleteException {
+
+    if (method.getReturnType().isInterface() == null) {
+      logger.log(TreeLogger.ERROR, "Return type must be an interface");
+      throw new UnableToCompleteException();
+    }
+
+    URL[] resources = ResourceGeneratorUtil.findResources(logger, context,
+        method, DEFAULT_EXTENSIONS);
+
+    if (resources.length == 0) {
+      logger.log(TreeLogger.ERROR, "At least one source must be specified");
+      throw new UnableToCompleteException();
+    }
+
+    // Create the AST and do a quick scan for requirements
+    CssStylesheet sheet = GenerateCssAst.exec(logger, resources);
+    stylesheetMap.put(method, sheet);
+    (new RequirementsCollector(logger, requirements)).accept(sheet);
+  }
+
+  /**
+   * Each distinct type of CssResource has a unique collection of values that it
+   * will return, excepting for those methods that are defined within an
+   * interface that is tagged with {@code @Shared}.
+   */
+  private void computeObfuscatedNames(TreeLogger logger) {
+    logger = logger.branch(TreeLogger.DEBUG, "Computing CSS class replacements");
+
+    SortedSet<JClassType> cssResourceSubtypes = computeOperableTypes(logger);
+
+    if (classPrefix == null) {
+      Adler32 checksum = new Adler32();
+      for (JClassType type : cssResourceSubtypes) {
+        checksum.update(Util.getBytes(type.getQualifiedSourceName()));
+      }
+      classPrefix = "G"
+          + Long.toString(checksum.getValue(), Character.MAX_RADIX);
+    }
+
+    int count = 0;
+    for (JClassType type : cssResourceSubtypes) {
+      Map<JMethod, String> replacements = new IdentityHashMap<JMethod, String>();
+      replacementsByClassAndMethod.put(type, replacements);
+
+      for (JMethod method : type.getOverridableMethods()) {
+        String name = method.getName();
+        if ("getName".equals(name) || "getText".equals(name)
+            || !stringType.equals(method.getReturnType())) {
+          continue;
+        }
+
+        // The user provided the class name to use
+        ClassName classNameOverride = method.getAnnotation(ClassName.class);
+        if (classNameOverride != null) {
+          name = classNameOverride.value();
+        }
+
+        String obfuscatedClassName;
+        if (prettyOutput) {
+          obfuscatedClassName = classPrefix + "-"
+              + type.getQualifiedSourceName().replaceAll("[.$]", "-") + "-"
+              + name;
+        } else {
+          obfuscatedClassName = classPrefix + makeIdent(count++);
+        }
+
+        replacements.put(method, obfuscatedClassName);
+
+        if (method.getEnclosingType() == type) {
+          Shared shared = type.getAnnotation(Shared.class);
+          if (shared != null) {
+            replacementsForSharedMethods.put(method, obfuscatedClassName);
+          }
+        }
+
+        logger.log(TreeLogger.SPAM, "Mapped " + type.getQualifiedSourceName()
+            + "." + name + " to " + obfuscatedClassName);
+      }
+    }
+  }
+
+  /**
+   * Returns all interfaces derived from CssResource, sorted by qualified name.
+   * <p>
+   * We'll ignore concrete implementations of CssResource, which include types
+   * previously-generated by CssResourceGenerator and user-provided
+   * implementations of CssResource, which aren't valid for use with
+   * CssResourceGenerator anyway. By ignoring newly-generated CssResource types,
+   * we'll ensure a stable ordering, regardless of the actual execution order
+   * used by the Generator framework.
+   * <p>
+   * It is still possible that additional pure-interfaces could be introduced by
+   * other generators, which would change the result of this computation, but
+   * there is presently no way to determine when, or by what means, a type was
+   * added to the TypeOracle.
+   */
+  private SortedSet<JClassType> computeOperableTypes(TreeLogger logger) {
+    logger = logger.branch(TreeLogger.DEBUG,
+        "Finding operable CssResource subtypes");
+
+    SortedSet<JClassType> toReturn = new TreeSet<JClassType>(
+        new JClassOrderComparator());
+
+    JClassType[] cssResourceSubtypes = cssResourceType.getSubtypes();
+    for (JClassType type : cssResourceSubtypes) {
+      if (type.isInterface() != null) {
+        logger.log(TreeLogger.SPAM, "Added " + type.getQualifiedSourceName());
+        toReturn.add(type);
+
+      } else {
+        logger.log(TreeLogger.SPAM, "Ignored " + type.getQualifiedSourceName());
+      }
+    }
+
+    return toReturn;
+  }
+
+  /**
+   * Compute the mapping of original class names to obfuscated type names for a
+   * given subtype of CssResource. Mappings are inherited from the type's
+   * supertypes.
+   */
+  private Map<JMethod, String> computeReplacementsForType(JClassType type) {
+    Map<JMethod, String> toReturn = new IdentityHashMap<JMethod, String>();
+
+    /*
+     * We check to see if the type is derived from CssResource so that we can
+     * handle the case of a CssResource type being derived from a
+     * non-CssResource base type. This basically collapses the non-CssResource
+     * base types into their least-derived CssResource subtypes.
+     */
+    if (type == null || !derivedFromCssResource(type)) {
+      return toReturn;
+    }
+
+    if (replacementsByClassAndMethod.containsKey(type)) {
+      toReturn.putAll(replacementsByClassAndMethod.get(type));
+    }
+
+    /*
+     * Replacements for methods defined in shared types will override any
+     * locally-computed values.
+     */
+    for (JMethod method : type.getOverridableMethods()) {
+      if (replacementsForSharedMethods.containsKey(method)) {
+        assert toReturn.containsKey(method);
+        toReturn.put(method, replacementsForSharedMethods.get(method));
+      }
+    }
+
+    return toReturn;
+  }
+
+  /**
+   * Determine if a type is derived from CssResource.
+   */
+  private boolean derivedFromCssResource(JClassType type) {
+    List<JClassType> superInterfaces = Arrays.asList(type.getImplementedInterfaces());
+    if (superInterfaces.contains(cssResourceType)) {
+      return true;
+    }
+
+    JClassType superClass = type.getSuperclass();
+    if (superClass != null) {
+      if (derivedFromCssResource(superClass)) {
+        return true;
+      }
+    }
+
+    for (JClassType superInterface : superInterfaces) {
+      if (derivedFromCssResource(superInterface)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Create a Java expression that evaluates to the string representation of the
+   * stylesheet resource.
+   */
+  private String makeExpression(TreeLogger logger, ResourceContext context,
+      JClassType cssResourceType, CssStylesheet sheet,
+      Map<String, Map<JMethod, String>> classReplacementsWithPrefix,
+      boolean strict) throws UnableToCompleteException {
+
+    try {
+
+      // Create CSS sprites
+      (new Spriter(logger, context)).accept(sheet);
+
+      // Perform @def and @eval substitutions
+      SubstitutionCollector collector = new SubstitutionCollector();
+      collector.accept(sheet);
+
+      (new SubstitutionReplacer(logger, context, collector.substitutions)).accept(sheet);
+
+      // Evaluate @if statements based on deferred binding properties
+      (new IfEvaluator(logger,
+          context.getGeneratorContext().getPropertyOracle())).accept(sheet);
+
+      // Rename css .class selectors
+      (new ClassRenamer(logger, classReplacementsWithPrefix, strict)).accept(sheet);
+
+      // Combine rules with identical selectors
+      if (enableMerge) {
+        // TODO This is an off-switch while this is being developed; remove
+        (new SplitRulesVisitor()).accept(sheet);
+        (new MergeIdenticalSelectorsVisitor()).accept(sheet);
+        (new MergeRulesByContentVisitor()).accept(sheet);
+      }
+
+      String standard = makeExpression(logger, context, cssResourceType, sheet,
+          prettyOutput);
+
+      (new RtlVisitor()).accept(sheet);
+
+      String reversed = makeExpression(logger, context, cssResourceType, sheet,
+          prettyOutput);
+
+      return "com.google.gwt.i18n.client.LocaleInfo.getCurrentLocale().isRTL() ? ("
+          + reversed + ") : (" + standard + ")";
+
+    } catch (CssCompilerException e) {
+      // Take this as a sign that one of the visitors was unhappy, but only
+      // log the stack trace if there's a causal (i.e. unknown) exception.
+      logger.log(TreeLogger.ERROR, "Unable to process CSS",
+          e.getCause() == null ? null : e);
+      throw new UnableToCompleteException();
+    }
+  }
+
+  /**
+   * Write the CssResource accessor method for simple String return values.
+   */
+  private void writeClassAssignment(SourceWriter sw, JMethod toImplement,
+      Map<JMethod, String> classReplacements) {
+
+    String replacement = classReplacements.get(toImplement);
+    assert replacement != null;
+
+    sw.println(toImplement.getReadableDeclaration(false, true, true, true, true)
+        + "{");
+    sw.indent();
+    sw.println("return \"" + replacement + "\";");
+    sw.outdent();
+    sw.println("}");
+  }
+
+  private void writeDefAssignment(TreeLogger logger, SourceWriter sw,
+      JMethod toImplement, CssStylesheet cssStylesheet)
+      throws UnableToCompleteException {
+    SubstitutionCollector collector = new SubstitutionCollector();
+    collector.accept(cssStylesheet);
+
+    String name = toImplement.getName();
+    // TODO: Annotation for override
+
+    CssDef def = collector.substitutions.get(name);
+    if (def == null) {
+      logger.log(TreeLogger.ERROR, "No @def rule for name " + name);
+      throw new UnableToCompleteException();
+    }
+
+    // TODO: Allow returning an array of values
+    if (def.getValues().size() != 1) {
+      logger.log(TreeLogger.ERROR, "@def rule " + name
+          + " must define exactly one value");
+      throw new UnableToCompleteException();
+    }
+
+    NumberValue numberValue = def.getValues().get(0).isNumberValue();
+
+    if (numberValue == null) {
+      logger.log(TreeLogger.ERROR, "The define named " + name
+          + " does not define a numeric value");
+      throw new UnableToCompleteException();
+    }
+
+    JPrimitiveType returnType = toImplement.getReturnType().isPrimitive();
+    assert returnType != null;
+
+    sw.print(toImplement.getReadableDeclaration(false, false, false, false,
+        true));
+    sw.println(" {");
+    sw.indent();
+    if (returnType == JPrimitiveType.INT || returnType == JPrimitiveType.LONG) {
+      sw.println("return " + Math.round(numberValue.getValue()) + ";");
+    } else if (returnType == JPrimitiveType.FLOAT) {
+      sw.println("return " + numberValue.getValue() + "F;");
+    } else if (returnType == JPrimitiveType.DOUBLE) {
+      sw.println("return " + numberValue.getValue() + ";");
+    } else {
+      logger.log(TreeLogger.ERROR, returnType.getQualifiedSourceName()
+          + " is not a valid return type for @def accessors");
+      throw new UnableToCompleteException();
+    }
+    sw.outdent();
+    sw.println("}");
+
+    numberValue.getValue();
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rg/DataResourceGenerator.java b/user/src/com/google/gwt/resources/rg/DataResourceGenerator.java
new file mode 100644
index 0000000..f90257a
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/DataResourceGenerator.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.resources.client.DataResource;
+import com.google.gwt.resources.ext.ResourceContext;
+import com.google.gwt.resources.ext.ResourceGeneratorUtil;
+import com.google.gwt.user.rebind.SourceWriter;
+import com.google.gwt.user.rebind.StringSourceWriter;
+
+import java.net.URL;
+
+/**
+ * Provides implementations of DataResource.
+ */
+public final class DataResourceGenerator extends AbstractResourceGenerator {
+  @Override
+  public String createAssignment(TreeLogger logger, ResourceContext context,
+      JMethod method) throws UnableToCompleteException {
+
+    URL[] resources = ResourceGeneratorUtil.findResources(logger, context,
+        method);
+
+    if (resources.length != 1) {
+      logger.log(TreeLogger.ERROR, "Exactly one resource must be specified",
+          null);
+      throw new UnableToCompleteException();
+    }
+
+    URL resource = resources[0];
+    String outputUrlExpression = context.deploy(resource, false);
+
+    SourceWriter sw = new StringSourceWriter();
+    // Write the expression to create the subtype.
+    sw.println("new " + DataResource.class.getName() + "() {");
+    sw.indent();
+
+    // Convenience when examining the generated code.
+    sw.println("// " + resource.toExternalForm());
+
+    sw.println("public String getUrl() {");
+    sw.indent();
+    sw.println("return " + outputUrlExpression + ";");
+    sw.outdent();
+    sw.println("}");
+
+    sw.println("public String getName() {");
+    sw.indent();
+    sw.println("return \"" + method.getName() + "\";");
+    sw.outdent();
+    sw.println("}");
+
+    sw.outdent();
+    sw.println("}");
+
+    return sw.toString();
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rg/ExternalTextResourceGenerator.java b/user/src/com/google/gwt/resources/rg/ExternalTextResourceGenerator.java
new file mode 100644
index 0000000..c5f3d31
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/ExternalTextResourceGenerator.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.Generator;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.core.ext.typeinfo.JType;
+import com.google.gwt.core.ext.typeinfo.TypeOracle;
+import com.google.gwt.dev.util.Util;
+import com.google.gwt.resources.client.TextResource;
+import com.google.gwt.resources.client.impl.ExternalTextResourcePrototype;
+import com.google.gwt.resources.ext.ClientBundleFields;
+import com.google.gwt.resources.ext.ClientBundleRequirements;
+import com.google.gwt.resources.ext.ResourceContext;
+import com.google.gwt.resources.ext.ResourceGeneratorUtil;
+import com.google.gwt.user.rebind.SourceWriter;
+import com.google.gwt.user.rebind.StringSourceWriter;
+
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Adds {@link ExternalTextResourcePrototype} objects to the bundle.
+ */
+public final class ExternalTextResourceGenerator extends
+    AbstractResourceGenerator {
+  private static final String[] DEFAULT_EXTENSIONS = new String[] {".txt"};
+  private StringBuffer data;
+  private boolean first;
+  private String urlExpression;
+  private Map<String, Integer> hashes;
+  private Map<String, Integer> offsets;
+  private int currentIndex;
+
+  private String externalTextUrlIdent;
+
+  private String externalTextCacheIdent;
+
+  @Override
+  public String createAssignment(TreeLogger logger, ResourceContext context,
+      JMethod method) throws UnableToCompleteException {
+    String name = method.getName();
+
+    SourceWriter sw = new StringSourceWriter();
+    sw.println("new " + ExternalTextResourcePrototype.class.getName() + "(");
+    sw.indent();
+    sw.println('"' + name + "\",");
+    // These are field names
+    sw.println(externalTextUrlIdent + ", " + externalTextCacheIdent + ", ");
+    sw.println(offsets.get(method.getName()).toString());
+    sw.outdent();
+    sw.print(")");
+
+    return sw.toString();
+  }
+
+  @Override
+  public void createFields(TreeLogger logger, ResourceContext context,
+      ClientBundleFields fields) throws UnableToCompleteException {
+    data.append(']');
+
+    urlExpression = context.deploy(
+        context.getClientBundleType().getQualifiedSourceName().replace('.', '_')
+            + "_jsonbundle.txt", "text/plain", data.toString().getBytes(), true);
+
+    TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle();
+    JClassType stringType = typeOracle.findType(String.class.getName());
+    assert stringType != null;
+
+    externalTextUrlIdent = fields.define(stringType, "externalTextUrl",
+        urlExpression, true, true);
+
+    JClassType textResourceType = typeOracle.findType(TextResource.class.getName());
+    assert textResourceType != null;
+    JType textResourceArrayType = typeOracle.getArrayType(textResourceType);
+
+    externalTextCacheIdent = fields.define(textResourceArrayType,
+        "externalTextCache", "new " + TextResource.class.getName() + "["
+            + currentIndex + "]", true, true);
+  }
+
+  @Override
+  public void init(TreeLogger logger, ResourceContext context)
+      throws UnableToCompleteException {
+    data = new StringBuffer("[\n");
+    first = true;
+    urlExpression = null;
+    hashes = new HashMap<String, Integer>();
+    offsets = new HashMap<String, Integer>();
+    currentIndex = 0;
+  }
+
+  @Override
+  public void prepare(TreeLogger logger, ResourceContext context,
+      ClientBundleRequirements requirements, JMethod method)
+      throws UnableToCompleteException {
+
+    URL[] urls = ResourceGeneratorUtil.findResources(logger, context, method,
+        DEFAULT_EXTENSIONS);
+
+    if (urls.length != 1) {
+      logger.log(TreeLogger.ERROR, "Exactly one resource must be specified",
+          null);
+      throw new UnableToCompleteException();
+    }
+
+    URL resource = urls[0];
+
+    String toWrite = Util.readURLAsString(resource);
+
+    // This de-duplicates strings in the bundle.
+    if (!hashes.containsKey(toWrite)) {
+      hashes.put(toWrite, currentIndex++);
+
+      if (!first) {
+        data.append(",\n");
+      } else {
+        first = false;
+      }
+
+      data.append('"');
+      data.append(Generator.escape(toWrite));
+      data.append('"');
+    }
+
+    // Store the (possibly n:1) mapping of resource function to bundle index.
+    offsets.put(method.getName(), hashes.get(toWrite));
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rg/GwtCreateResourceGenerator.java b/user/src/com/google/gwt/resources/rg/GwtCreateResourceGenerator.java
new file mode 100644
index 0000000..8b981f4
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/GwtCreateResourceGenerator.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.core.ext.typeinfo.JParameterizedType;
+import com.google.gwt.resources.client.GwtCreateResource.ClassType;
+import com.google.gwt.resources.ext.ResourceContext;
+
+/**
+ * Provides implementations of GwtCreateResource.
+ */
+public class GwtCreateResourceGenerator extends AbstractResourceGenerator {
+
+  @Override
+  public String createAssignment(TreeLogger logger, ResourceContext context,
+      JMethod method) throws UnableToCompleteException {
+    JParameterizedType returnType = method.getReturnType().isParameterized();
+    assert returnType != null;
+
+    JClassType args[] = returnType.getTypeArgs();
+    assert args.length == 1;
+
+    ClassType override = method.getAnnotation(ClassType.class);
+    JClassType toCreate;
+    if (override != null) {
+      toCreate = context.getGeneratorContext().getTypeOracle().findType(
+          override.value().getName().replace('$', '.'));
+      assert toCreate != null;
+    } else {
+      toCreate = args[0];
+    }
+
+    JClassType gwtType = context.getGeneratorContext().getTypeOracle().findType(
+        GWT.class.getName());
+    assert gwtType != null;
+
+    return "new " + returnType.getParameterizedQualifiedSourceName()
+        + "() {\n public " + toCreate.getQualifiedSourceName()
+        + " create() {\n return " + gwtType.getQualifiedSourceName()
+        + ".create(" + toCreate.getQualifiedSourceName() + ".class);}\n"
+        + "public String getName() { return \"" + method.getName() + "\";}}";
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rg/ImageBundleBuilder.java b/user/src/com/google/gwt/resources/rg/ImageBundleBuilder.java
new file mode 100644
index 0000000..46ce8c2
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/ImageBundleBuilder.java
@@ -0,0 +1,662 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.resources.ext.ResourceContext;
+
+import java.awt.Graphics2D;
+import java.awt.geom.AffineTransform;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import javax.imageio.ImageIO;
+
+/**
+ * Accumulates state for the bundled image.
+ */
+class ImageBundleBuilder {
+  /**
+   * Abstracts the process of arranging a number of images into a composite
+   * image.
+   */
+  interface Arranger {
+    /**
+     * Determine the total area required to store a composite image.
+     */
+    Size arrangeImages(Collection<HasRect> rects);
+  }
+
+  /**
+   * Arranges the images to try to decrease the overall area of the resulting
+   * bundle. This uses a strategy that is basically Next-Fit Decreasing Height
+   * Decreasing Width (NFDHDW). The rectangles to be packed are sorted in
+   * decreasing order by height. The tallest rectangle is placed at the far
+   * left. We attempt to stack the remaining rectangles on top of one another to
+   * construct as many columns as necessary. After finishing each column, we
+   * also attempt to do some horizontal packing to fill up the space left due to
+   * widths of rectangles differing in the column.
+   */
+  static class BestFitArranger implements Arranger {
+    private static final Comparator<HasRect> decreasingHeightComparator = new Comparator<HasRect>() {
+      public int compare(HasRect a, HasRect b) {
+        final int c = b.getHeight() - a.getHeight();
+        // If we encounter equal heights, use the name to keep things
+        // deterministic.
+        return (c != 0) ? c : b.getName().compareTo(a.getName());
+      }
+    };
+
+    private static final Comparator<HasRect> decreasingWidthComparator = new Comparator<HasRect>() {
+      public int compare(HasRect a, HasRect b) {
+        final int c = b.getWidth() - a.getWidth();
+        // If we encounter equal heights, use the name to keep things
+        // deterministic.
+        return (c != 0) ? c : b.getName().compareTo(a.getName());
+      }
+    };
+
+    public Size arrangeImages(Collection<HasRect> rects) {
+      if (rects.size() == 0) {
+        return new Size(0, 0);
+      }
+
+      // Create a list of ImageRects ordered by decreasing height used for
+      // constructing columns.
+      final ArrayList<HasRect> rectsOrderedByHeight = new ArrayList<HasRect>(
+          rects);
+      Collections.sort(rectsOrderedByHeight, decreasingHeightComparator);
+
+      // Create a list of ImageRects ordered by decreasing width used for
+      // packing
+      // individual columns.
+      final ArrayList<HasRect> rectsOrderedByWidth = new ArrayList<HasRect>(
+          rects);
+      Collections.sort(rectsOrderedByWidth, decreasingWidthComparator);
+
+      // Place the first, tallest image as the first column.
+      final HasRect first = rectsOrderedByHeight.get(0);
+      first.setPosition(0, 0);
+
+      // Setup state for laying things cumulatively.
+      int curX = first.getWidth();
+      final int colH = first.getHeight();
+
+      for (int i = 1, n = rectsOrderedByHeight.size(); i < n; i++) {
+        // If this ImageRect has been positioned already, move on.
+        if (rectsOrderedByHeight.get(i).hasBeenPositioned()) {
+          continue;
+        }
+
+        int colW = 0;
+        int curY = 0;
+
+        final ArrayList<HasRect> rectsInColumn = new ArrayList<HasRect>();
+        for (int j = i; j < n; j++) {
+          final HasRect current = rectsOrderedByHeight.get(j);
+          // Look for rects that have not been positioned with a small enough
+          // height to go in this column.
+          if (!current.hasBeenPositioned()
+              && (curY + current.getHeight()) <= colH) {
+
+            // Set the horizontal position here, the top field will be set in
+            // arrangeColumn after we've collected a full set of ImageRects.
+            current.setPosition(curX, 0);
+            colW = Math.max(colW, current.getWidth());
+            curY += current.getHeight();
+
+            // Keep the ImageRects in this column in decreasing order by width.
+            final int pos = Collections.binarySearch(rectsInColumn, current,
+                decreasingWidthComparator);
+            assert pos < 0;
+            rectsInColumn.add(-1 - pos, current);
+          }
+        }
+
+        // Having selected a set of ImageRects that fill out this column
+        // vertical,
+        // now we'll scan the remaining ImageRects to try to fit some in the
+        // horizontal gaps.
+        if (!rectsInColumn.isEmpty()) {
+          arrangeColumn(rectsInColumn, rectsOrderedByWidth);
+        }
+
+        // We're done with that column, so move the horizontal accumulator by
+        // the
+        // width of the column we just finished.
+        curX += colW;
+      }
+
+      return new Size(curX, colH);
+    }
+
+    /**
+     * Companion method to {@link #arrangeImages()}. This method does a best
+     * effort horizontal packing of a column after it was packed vertically.
+     * This is the Decreasing Width part of Next-Fit Decreasing Height
+     * Decreasing Width. The basic strategy is to sort the remaining rectangles
+     * by decreasing width and try to fit them to the left of each of the
+     * rectangles we've already picked for this column.
+     * 
+     * @param rectsInColumn the ImageRects that were already selected for this
+     *          column
+     * @param remainingRectsOrderedByWidth the sub list of ImageRects that may
+     *          not have been positioned yet
+     */
+    private void arrangeColumn(List<HasRect> rectsInColumn,
+        List<HasRect> remainingRectsOrderedByWidth) {
+      final HasRect first = rectsInColumn.get(0);
+
+      final int columnWidth = first.getWidth();
+      int curY = first.getHeight();
+
+      // Skip this first ImageRect because it is guaranteed to consume the full
+      // width of the column.
+      for (int i = 1, m = rectsInColumn.size(); i < m; i++) {
+        final HasRect r = rectsInColumn.get(i);
+        // The ImageRect was previously positioned horizontally, now set the top
+        // field.
+        r.setPosition(r.getLeft(), curY);
+        int curX = r.getWidth();
+
+        // Search for ImageRects that are shorter than the left most ImageRect
+        // and
+        // narrow enough to fit in the column.
+        for (int j = 0, n = remainingRectsOrderedByWidth.size(); j < n; j++) {
+          final HasRect current = remainingRectsOrderedByWidth.get(j);
+          if (!current.hasBeenPositioned()
+              && (curX + current.getWidth()) <= columnWidth
+              && (current.getHeight() <= r.getHeight())) {
+            current.setPosition(r.getLeft() + curX, r.getTop());
+            curX += current.getWidth();
+          }
+        }
+
+        // Update the vertical accumulator so we'll know where to place the next
+        // ImageRect.
+        curY += r.getHeight();
+      }
+    }
+  }
+
+  /**
+   * A mockable interface to test the image arrangement algorithms.
+   */
+  interface HasRect {
+
+    int getHeight();
+
+    BufferedImage getImage();
+
+    int getLeft();
+
+    String getName();
+
+    int getTop();
+
+    AffineTransform getTransform();
+
+    int getWidth();
+
+    boolean hasBeenPositioned();
+
+    void setPosition(int left, int top);
+
+    AffineTransform transform();
+  }
+
+  /**
+   * Performs a simple horizontal arrangement of rectangles. Images will be
+   * tiled vertically to fill to fill the full height of the image.
+   */
+  static class HorizontalArranger implements Arranger {
+    public Size arrangeImages(Collection<HasRect> rects) {
+      int height = 1;
+      int width = 0;
+
+      for (HasRect rect : rects) {
+        rect.setPosition(width, 0);
+        width += rect.getWidth();
+        height = lcm(height, rect.getHeight());
+      }
+
+      List<HasRect> toAdd = new ArrayList<HasRect>();
+      for (HasRect rect : rects) {
+        int y = rect.getHeight();
+        while (y < height) {
+          ImageRect newRect = new ImageRect(rect);
+          newRect.setPosition(rect.getLeft(), y);
+          y += rect.getHeight();
+          toAdd.add(newRect);
+        }
+      }
+      rects.addAll(toAdd);
+
+      return new Size(width, height);
+    }
+  }
+
+  /**
+   * Does not rearrange the rectangles, but simply computes the size of the
+   * canvas needed to hold the images in their current positions.
+   */
+  static class IdentityArranger implements Arranger {
+    public Size arrangeImages(Collection<HasRect> rects) {
+      int height = 0;
+      int width = 0;
+
+      for (HasRect rect : rects) {
+        height = Math.max(height, rect.getTop() + rect.getHeight());
+        width = Math.max(width, rect.getLeft() + rect.getWidth());
+      }
+
+      return new Size(width, height);
+    }
+  }
+
+  /**
+   * The rectangle at which the original image is placed into the composite
+   * image.
+   */
+  static class ImageRect implements HasRect {
+
+    private boolean hasBeenPositioned;
+    private final int height, width;
+    private final BufferedImage image;
+    private int left, top;
+    private final String name;
+    private final AffineTransform transform = new AffineTransform();
+
+    /**
+     * Copy constructor.
+     */
+    public ImageRect(HasRect other) {
+      this.name = other.getName();
+      this.height = other.getHeight();
+      this.width = other.getWidth();
+      this.image = other.getImage();
+      this.left = other.getLeft();
+      this.top = other.getTop();
+      setTransform(other.getTransform());
+    }
+
+    public ImageRect(String name, BufferedImage image) {
+      this.name = name;
+      this.image = image;
+      this.width = image.getWidth();
+      this.height = image.getHeight();
+    }
+
+    public int getHeight() {
+      return height;
+    }
+
+    public BufferedImage getImage() {
+      return image;
+    }
+
+    public int getLeft() {
+      return left;
+    }
+
+    public String getName() {
+      return name;
+    }
+
+    public int getTop() {
+      return top;
+    }
+
+    public AffineTransform getTransform() {
+      return new AffineTransform(transform);
+    }
+
+    public int getWidth() {
+      return width;
+    }
+
+    public boolean hasBeenPositioned() {
+      return hasBeenPositioned;
+    }
+
+    public void setPosition(int left, int top) {
+      hasBeenPositioned = true;
+      this.left = left;
+      this.top = top;
+    }
+
+    public void setTransform(AffineTransform transform) {
+      this.transform.setTransform(transform);
+    }
+
+    public AffineTransform transform() {
+      AffineTransform toReturn = new AffineTransform();
+      toReturn.translate(left, top);
+      toReturn.concatenate(transform);
+
+      assert checkTransform(toReturn);
+      return toReturn;
+    }
+
+    private boolean checkTransform(AffineTransform tx) {
+      double[] in = {0, 0, width, height};
+      double[] out = {0, 0, 0, 0};
+
+      tx.transform(in, 0, out, 0, 2);
+
+      assert width == Math.abs(out[0] - out[2]);
+      assert height == Math.abs(out[1] - out[3]);
+      assert out[0] >= 0;
+      assert out[1] >= 0;
+      assert out[2] >= 0;
+      assert out[3] >= 0;
+
+      return true;
+    }
+  }
+
+  /**
+   * Used to return the size of the resulting image from the method
+   * {@link ImageBundleBuilder#arrangeImages()}.
+   */
+  static class Size {
+    private final int width, height;
+
+    Size(int width, int height) {
+      this.width = width;
+      this.height = height;
+    }
+  }
+
+  /**
+   * Performs a simple vertical arrangement of rectangles. Images will be tiled
+   * horizontally to fill the full width of the image.
+   */
+  static class VerticalArranger implements Arranger {
+    public Size arrangeImages(Collection<HasRect> rects) {
+      int height = 0;
+      int width = 1;
+
+      for (HasRect rect : rects) {
+        rect.setPosition(0, height);
+        width = lcm(width, rect.getWidth());
+        height += rect.getHeight();
+      }
+
+      List<HasRect> toAdd = new ArrayList<HasRect>();
+      for (HasRect rect : rects) {
+        int x = rect.getWidth();
+        while (x < width) {
+          ImageRect newRect = new ImageRect(rect);
+          newRect.setPosition(x, rect.getTop());
+          x += rect.getWidth();
+          toAdd.add(newRect);
+        }
+      }
+      rects.addAll(toAdd);
+
+      return new Size(width, height);
+    }
+  }
+
+  /*
+   * Only PNG is supported right now. In the future, we may be able to infer the
+   * best output type, and get rid of this constant.
+   */
+  private static final String BUNDLE_FILE_TYPE = "png";
+  private static final String BUNDLE_MIME_TYPE = "image/png";
+  private static final int IMAGE_MAX_SIZE = 256;
+
+  public static byte[] toPng(TreeLogger logger, HasRect rect)
+      throws UnableToCompleteException {
+    // Create the bundled image.
+    BufferedImage bundledImage = new BufferedImage(rect.getWidth(),
+        rect.getHeight(), BufferedImage.TYPE_INT_ARGB_PRE);
+    Graphics2D g2d = bundledImage.createGraphics();
+
+    g2d.drawImage(rect.getImage(), rect.transform(), null);
+    g2d.dispose();
+
+    byte[] imageBytes;
+
+    try {
+      ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
+      ImageIO.write(bundledImage, BUNDLE_FILE_TYPE, byteOutputStream);
+      imageBytes = byteOutputStream.toByteArray();
+    } catch (IOException e) {
+      logger.log(TreeLogger.ERROR,
+          "Unable to generate file name for image bundle file", null);
+      throw new UnableToCompleteException();
+    }
+    return imageBytes;
+  }
+
+  /**
+   * Compute the greatest common denominator of two numbers.
+   */
+  private static int gcd(int a, int b) {
+    while (b != 0) {
+      int t = b;
+      b = a % b;
+      a = t;
+    }
+    return a;
+  }
+
+  /**
+   * Compute the least common multiple of two numbers. This is used by
+   * {@link HorizontalArranger} and {@link VerticalArranger} to determine how
+   * large the composite image should be to allow every image to line up when
+   * repeated.
+   */
+  private static int lcm(int a, int b) {
+    return b / gcd(a, b) * a;
+  }
+
+  private final Map<String, ImageRect> imageNameToImageRectMap = new HashMap<String, ImageRect>();
+
+  public ImageBundleBuilder() {
+  }
+
+  /**
+   * Copy constructor.
+   */
+  public ImageBundleBuilder(ImageBundleBuilder other) {
+    for (Map.Entry<String, ImageRect> entry : other.imageNameToImageRectMap.entrySet()) {
+      imageNameToImageRectMap.put(entry.getKey(), new ImageRect(
+          entry.getValue()));
+    }
+  }
+
+  /**
+   * Assimilates the image associated with a particular image method into the
+   * master composite. If the method names an image that has already been
+   * assimilated, the existing image rectangle is reused.
+   * 
+   * @param logger a hierarchical logger which logs to the hosted console
+   * @param imageName the name of an image that can be found on the classpath
+   * @param resource the URL from which the image data wil be loaded
+   * @throws UnableToCompleteException if the image with name
+   *           <code>imageName</code> cannot be added to the master composite
+   *           image
+   */
+  public ImageRect assimilate(TreeLogger logger, String imageName, URL resource)
+      throws UnableToCompleteException, UnsuitableForStripException {
+
+    /*
+     * Decide whether or not we need to add to the composite image. Either way,
+     * we associated it with the rectangle of the specified image as it exists
+     * within the composite image. Note that the coordinates of the rectangle
+     * aren't computed until the composite is written.
+     */
+    ImageRect rect = getMapping(imageName);
+    if (rect == null) {
+      // Assimilate the image into the composite.
+      rect = addImage(logger, imageName, resource);
+
+      imageNameToImageRectMap.put(imageName, rect);
+    }
+    return rect;
+  }
+
+  public int getImageCount() {
+    return imageNameToImageRectMap.size();
+  }
+
+  public ImageRect getMapping(String imageName) {
+    return imageNameToImageRectMap.get(imageName);
+  }
+
+  public ImageRect removeMapping(String imageName) {
+    return imageNameToImageRectMap.remove(imageName);
+  }
+
+  /**
+   * Write all images into the output.
+   * 
+   * @param logger a hierarchical logger which logs to the hosted console
+   * @param context the local ResourceContext that is being used to accumulate
+   *          output files
+   * @param arranger a provider of image layout logic
+   * @return a Java expression which will evaluate to the location of the
+   *         composite image at runtime
+   */
+  public String writeBundledImage(TreeLogger logger, ResourceContext context,
+      Arranger arranger) throws UnableToCompleteException {
+
+    if (imageNameToImageRectMap.isEmpty()) {
+      return null;
+    }
+
+    // Create the bundled image from all of the constituent images.
+    BufferedImage bundledImage = drawBundledImage(arranger);
+
+    // Write the bundled image into a byte array, so that we can compute
+    // its strong name.
+    byte[] imageBytes;
+
+    try {
+      ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
+      ImageIO.write(bundledImage, BUNDLE_FILE_TYPE, byteOutputStream);
+      imageBytes = byteOutputStream.toByteArray();
+    } catch (IOException e) {
+      logger.log(TreeLogger.ERROR,
+          "Unable to generate file name for image bundle file", null);
+      throw new UnableToCompleteException();
+    }
+
+    String bundleFileName = context.deploy(
+        context.getClientBundleType().getQualifiedSourceName() + ".cache."
+            + BUNDLE_FILE_TYPE, BUNDLE_MIME_TYPE, imageBytes, false);
+
+    return bundleFileName;
+  }
+
+  private ImageRect addImage(TreeLogger logger, String imageName, URL imageUrl)
+      throws UnableToCompleteException, UnsuitableForStripException {
+
+    logger = logger.branch(TreeLogger.TRACE,
+        "Adding image '" + imageName + "'", null);
+
+    BufferedImage image;
+    // Load the image
+    try {
+      image = ImageIO.read(imageUrl);
+    } catch (IllegalArgumentException iex) {
+      if (imageName.toLowerCase().endsWith("png")
+          && iex.getMessage() != null
+          && iex.getStackTrace()[0].getClassName().equals(
+              "javax.imageio.ImageTypeSpecifier$Indexed")) {
+        logger.log(TreeLogger.ERROR,
+            "Unable to read image. The image may not be in valid PNG format. "
+                + "This problem may also be due to a bug in versions of the "
+                + "JRE prior to 1.6. See "
+                + "http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5098176 "
+                + "for more information. If this bug is the cause of the "
+                + "error, try resaving the image using a different image "
+                + "program, or upgrade to a newer JRE.", null);
+        throw new UnableToCompleteException();
+      } else {
+        throw iex;
+      }
+    } catch (IOException e) {
+      logger.log(TreeLogger.ERROR, "Unable to read image resource", null);
+      throw new UnableToCompleteException();
+    }
+
+    if (image == null) {
+      logger.log(TreeLogger.ERROR, "Unrecognized image file format", null);
+      throw new UnableToCompleteException();
+    }
+
+    ImageRect toReturn = new ImageRect(imageName, image);
+
+    if (toReturn.height > IMAGE_MAX_SIZE || toReturn.width > IMAGE_MAX_SIZE) {
+      throw new UnsuitableForStripException(toReturn);
+    }
+
+    return toReturn;
+  }
+
+  /**
+   * This method creates the bundled image through the composition of the other
+   * images.
+   * 
+   * In this particular implementation, we use NFDHDW (see
+   * {@link #arrangeImages()}) to get an approximate optimal image packing.
+   * 
+   * The most important aspect of drawing the bundled image is that it be drawn
+   * in a deterministic way. The drawing of the image should not rely on
+   * implementation details of the Generator system which may be subject to
+   * change.
+   */
+  private BufferedImage drawBundledImage(Arranger arranger) {
+
+    /*
+     * There is no need to impose any order here, because arrangeImages will
+     * position the ImageRects in a deterministic fashion, even though we might
+     * paint them in a non-deterministic order.
+     */
+    Collection<HasRect> imageRects = new LinkedList<HasRect>(
+        imageNameToImageRectMap.values());
+
+    // Arrange images and determine the size of the resulting bundle.
+    Size size = arranger.arrangeImages(imageRects);
+
+    // Create the bundled image.
+    BufferedImage bundledImage = new BufferedImage(size.width, size.height,
+        BufferedImage.TYPE_INT_ARGB_PRE);
+    Graphics2D g2d = bundledImage.createGraphics();
+
+    for (HasRect imageRect : imageRects) {
+      g2d.drawImage(imageRect.getImage(), imageRect.transform(), null);
+    }
+    g2d.dispose();
+
+    return bundledImage;
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rg/ImageResourceGenerator.java b/user/src/com/google/gwt/resources/rg/ImageResourceGenerator.java
new file mode 100644
index 0000000..e9c38a5
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/ImageResourceGenerator.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.core.ext.typeinfo.TypeOracle;
+import com.google.gwt.resources.client.ImageResource.ImageOptions;
+import com.google.gwt.resources.client.ImageResource.RepeatStyle;
+import com.google.gwt.resources.client.impl.ImageResourcePrototype;
+import com.google.gwt.resources.ext.ClientBundleFields;
+import com.google.gwt.resources.ext.ClientBundleRequirements;
+import com.google.gwt.resources.ext.ResourceContext;
+import com.google.gwt.resources.ext.ResourceGeneratorUtil;
+import com.google.gwt.resources.rg.ImageBundleBuilder.Arranger;
+import com.google.gwt.resources.rg.ImageBundleBuilder.ImageRect;
+import com.google.gwt.user.rebind.SourceWriter;
+import com.google.gwt.user.rebind.StringSourceWriter;
+
+import java.awt.geom.AffineTransform;
+import java.net.URL;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Builds an image strip for all ImageResources defined within an ClientBundle.
+ */
+public final class ImageResourceGenerator extends AbstractResourceGenerator {
+  private static final String[] DEFAULT_EXTENSIONS = new String[] {
+      ".png", ".jpg", ".gif", ".bmp"};
+  private Map<String, ImageRect> imageRectsByName;
+  private Map<ImageRect, ImageBundleBuilder> buildersByImageRect;
+  private Map<RepeatStyle, ImageBundleBuilder> buildersByRepeatStyle;
+  private Map<ImageBundleBuilder, String[]> urlsByBuilder;
+  private Map<ImageRect, String[]> urlsByExternalImageRect;
+  private Map<ImageRect, ImageBundleBuilder> rtlImages;
+
+  @Override
+  public String createAssignment(TreeLogger logger, ResourceContext context,
+      JMethod method) throws UnableToCompleteException {
+    String name = method.getName();
+
+    SourceWriter sw = new StringSourceWriter();
+    sw.println("new " + ImageResourcePrototype.class.getName() + "(");
+    sw.indent();
+    sw.println('"' + name + "\",");
+
+    ImageRect rect = imageRectsByName.get(name);
+    assert rect != null : "No ImageRect ever computed for " + name;
+
+    String[] urlExpressions;
+    {
+      ImageBundleBuilder builder = buildersByImageRect.get(rect);
+      if (builder == null) {
+        urlExpressions = urlsByExternalImageRect.get(rect);
+      } else {
+        urlExpressions = urlsByBuilder.get(builder);
+      }
+    }
+    assert urlExpressions != null : "No URL expression for " + name;
+    assert urlExpressions.length == 2;
+
+    if (urlExpressions[1] == null) {
+      sw.println(urlExpressions[0] + ",");
+    } else {
+      sw.println("com.google.gwt.i18n.client.LocaleInfo.getCurrentLocale().isRTL() ?"
+          + urlExpressions[1] + " : " + urlExpressions[0] + ",");
+    }
+    sw.println(rect.getLeft() + ", " + rect.getTop() + ", " + rect.getWidth()
+        + ", " + rect.getHeight());
+
+    sw.outdent();
+    sw.print(")");
+
+    return sw.toString();
+  }
+
+  @Override
+  public void createFields(TreeLogger logger, ResourceContext context,
+      ClientBundleFields fields) throws UnableToCompleteException {
+
+    TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle();
+    JClassType stringType = typeOracle.findType(String.class.getName());
+    assert stringType != null;
+
+    Map<ImageBundleBuilder, String> prettyNames = new IdentityHashMap<ImageBundleBuilder, String>();
+
+    for (Map.Entry<RepeatStyle, ImageBundleBuilder> entry : buildersByRepeatStyle.entrySet()) {
+      RepeatStyle repeatStyle = entry.getKey();
+      ImageBundleBuilder builder = entry.getValue();
+      Arranger arranger;
+
+      switch (repeatStyle) {
+        case None:
+          arranger = new ImageBundleBuilder.BestFitArranger();
+          break;
+        case Horizontal:
+          arranger = new ImageBundleBuilder.VerticalArranger();
+          break;
+        case Vertical:
+          arranger = new ImageBundleBuilder.HorizontalArranger();
+          break;
+        case Both:
+          // This is taken care of when writing the external images;
+          continue;
+        default:
+          logger.log(TreeLogger.ERROR, "Unknown RepeatStyle" + repeatStyle);
+          throw new UnableToCompleteException();
+      }
+
+      String bundleUrlExpression = builder.writeBundledImage(logger.branch(
+          TreeLogger.DEBUG, "Writing image strip", null), context, arranger);
+
+      if (bundleUrlExpression == null) {
+        continue;
+      }
+
+      String prettyName = "imageUrl" + repeatStyle;
+      prettyNames.put(builder, prettyName);
+      String fieldName = fields.define(stringType, prettyName,
+          bundleUrlExpression, true, true);
+      String[] strings = {fieldName, null};
+      urlsByBuilder.put(builder, strings);
+    }
+
+    if (rtlImages.size() > 0) {
+      Set<ImageBundleBuilder> rtlBuilders = new HashSet<ImageBundleBuilder>();
+
+      for (Map.Entry<ImageRect, ImageBundleBuilder> entry : rtlImages.entrySet()) {
+        ImageRect rtlImage = entry.getKey();
+
+        AffineTransform tx = new AffineTransform();
+        tx.setTransform(-1, 0, 0, 1, rtlImage.getWidth(), 0);
+
+        rtlImage.setTransform(tx);
+
+        if (buildersByImageRect.containsKey(rtlImage)) {
+          rtlBuilders.add(buildersByImageRect.get(rtlImage));
+        } else {
+          String[] strings = urlsByExternalImageRect.get(rtlImage);
+          assert strings != null;
+          byte[] imageBytes = ImageBundleBuilder.toPng(logger, rtlImage);
+          strings[1] = context.deploy(rtlImage.getName() + "_rtl.png",
+              "image/png", imageBytes, false);
+        }
+      }
+
+      for (ImageBundleBuilder builder : rtlBuilders) {
+        String bundleUrlExpression = builder.writeBundledImage(logger.branch(
+            TreeLogger.DEBUG, "Writing image strip", null), context,
+            new ImageBundleBuilder.IdentityArranger());
+
+        if (bundleUrlExpression == null) {
+          continue;
+        }
+
+        String prettyName = prettyNames.get(builder);
+        String[] strings = urlsByBuilder.get(builder);
+        assert strings != null;
+
+        strings[1] = fields.define(stringType, prettyName + "_rtl",
+            bundleUrlExpression, true, true);
+      }
+    }
+  }
+
+  @Override
+  public void init(TreeLogger logger, ResourceContext context) {
+    imageRectsByName = new HashMap<String, ImageRect>();
+    buildersByImageRect = new IdentityHashMap<ImageRect, ImageBundleBuilder>();
+    buildersByRepeatStyle = new EnumMap<RepeatStyle, ImageBundleBuilder>(
+        RepeatStyle.class);
+    rtlImages = new IdentityHashMap<ImageRect, ImageBundleBuilder>();
+    urlsByBuilder = new IdentityHashMap<ImageBundleBuilder, String[]>();
+    urlsByExternalImageRect = new IdentityHashMap<ImageRect, String[]>();
+  }
+
+  @Override
+  public void prepare(TreeLogger logger, ResourceContext context,
+      ClientBundleRequirements requirements, JMethod method)
+      throws UnableToCompleteException {
+    URL[] resources = ResourceGeneratorUtil.findResources(logger, context,
+        method, DEFAULT_EXTENSIONS);
+
+    if (resources.length != 1) {
+      logger.log(TreeLogger.ERROR, "Exactly one image may be specified", null);
+      throw new UnableToCompleteException();
+    }
+
+    ImageBundleBuilder builder = getBuilder(method);
+    URL resource = resources[0];
+    String name = method.getName();
+
+    ImageRect rect;
+    try {
+      rect = builder.assimilate(logger, name, resource);
+      if (context.supportsDataUrls()
+          || getRepeatStyle(method) == RepeatStyle.Both) {
+        // Just use the calculated meta-data
+        builder.removeMapping(name);
+        rect.setPosition(0, 0);
+        throw new UnsuitableForStripException(rect);
+      }
+      buildersByImageRect.put(rect, builder);
+    } catch (UnsuitableForStripException e) {
+      // Add the image to the output as a separate resource
+      rect = e.getImageRect();
+      byte[] imageBytes = ImageBundleBuilder.toPng(logger, rect);
+      String urlExpression = context.deploy(rect.getName() + ".png",
+          "image/png", imageBytes, false);
+      urlsByExternalImageRect.put(rect, new String[] {urlExpression, null});
+    }
+
+    imageRectsByName.put(name, rect);
+
+    if (getFlipRtl(method)) {
+      rtlImages.put(rect, null);
+    }
+  }
+
+  private ImageBundleBuilder getBuilder(JMethod method) {
+    RepeatStyle repeatStyle = getRepeatStyle(method);
+    ImageBundleBuilder builder = buildersByRepeatStyle.get(repeatStyle);
+    if (builder == null) {
+      builder = new ImageBundleBuilder();
+      buildersByRepeatStyle.put(repeatStyle, builder);
+    }
+    return builder;
+  }
+
+  private boolean getFlipRtl(JMethod method) {
+    ImageOptions options = method.getAnnotation(ImageOptions.class);
+    if (options == null) {
+      return false;
+    } else {
+      return options.flipRtl();
+    }
+  }
+
+  private RepeatStyle getRepeatStyle(JMethod method) {
+    ImageOptions options = method.getAnnotation(ImageOptions.class);
+    if (options == null) {
+      return RepeatStyle.None;
+    } else {
+      return options.repeatStyle();
+    }
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rg/TextResourceGenerator.java b/user/src/com/google/gwt/resources/rg/TextResourceGenerator.java
new file mode 100644
index 0000000..88b3d33
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/TextResourceGenerator.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.Generator;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.dev.util.Util;
+import com.google.gwt.resources.client.TextResource;
+import com.google.gwt.resources.ext.ResourceContext;
+import com.google.gwt.resources.ext.ResourceGeneratorUtil;
+import com.google.gwt.user.rebind.SourceWriter;
+import com.google.gwt.user.rebind.StringSourceWriter;
+
+import java.net.URL;
+
+/**
+ * Provides implementations of TextResource.
+ */
+public final class TextResourceGenerator extends AbstractResourceGenerator {
+
+  private static final String[] DEFAULT_EXTENSIONS = new String[] {".txt"};
+
+  @Override
+  public String createAssignment(TreeLogger logger, ResourceContext context,
+      JMethod method) throws UnableToCompleteException {
+    URL[] resources = ResourceGeneratorUtil.findResources(logger, context,
+        method, DEFAULT_EXTENSIONS);
+
+    if (resources.length != 1) {
+      logger.log(TreeLogger.ERROR, "Exactly one resource must be specified",
+          null);
+      throw new UnableToCompleteException();
+    }
+
+    URL resource = resources[0];
+
+    SourceWriter sw = new StringSourceWriter();
+    // Write the expression to create the subtype.
+    sw.println("new " + TextResource.class.getName() + "() {");
+    sw.indent();
+
+    // Convenience when examining the generated code.
+    sw.println("// " + resource.toExternalForm());
+
+    sw.println("public String getText() {");
+    sw.indent();
+
+    String toWrite = Util.readURLAsString(resource);
+
+    sw.println("return \"" + Generator.escape(toWrite) + "\";");
+    sw.outdent();
+    sw.println("}");
+
+    sw.println("public String getName() {");
+    sw.indent();
+    sw.println("return \"" + method.getName() + "\";");
+    sw.outdent();
+    sw.println("}");
+
+    sw.outdent();
+    sw.println("}");
+
+    return sw.toString();
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rg/UnsuitableForStripException.java b/user/src/com/google/gwt/resources/rg/UnsuitableForStripException.java
new file mode 100644
index 0000000..038dfa8
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/UnsuitableForStripException.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2007 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+/**
+ * Indicates that an image is not suitable for being added to an image strip.
+ */
+class UnsuitableForStripException extends Exception {
+  
+  private static final long serialVersionUID = -1;
+  private final ImageBundleBuilder.ImageRect rect;
+  
+  public UnsuitableForStripException(ImageBundleBuilder.ImageRect rect) {
+    this.rect = rect;
+  }
+  
+  public UnsuitableForStripException(ImageBundleBuilder.ImageRect rect, String msg) {
+    super(msg);
+    this.rect = rect;
+  }
+  
+  public UnsuitableForStripException(String msg, Throwable cause) {
+    super(msg, cause);
+    this.rect = null;
+  }
+  
+  public ImageBundleBuilder.ImageRect getImageRect() {
+    return rect;
+  }
+}
diff --git a/user/src/com/google/gwt/user/rebind/StringSourceWriter.java b/user/src/com/google/gwt/user/rebind/StringSourceWriter.java
new file mode 100644
index 0000000..78a2cd5
--- /dev/null
+++ b/user/src/com/google/gwt/user/rebind/StringSourceWriter.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.rebind;
+
+import com.google.gwt.core.ext.TreeLogger;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+/**
+ * A SourceWriter that accumulates source and returns it in the
+ * {@link #toString()} method.
+ */
+public class StringSourceWriter implements SourceWriter {
+
+  private final StringWriter buffer = new StringWriter();
+  private int indentLevel = 0;
+  private String indentPrefix = "";
+  private boolean needsIndent;
+  private final PrintWriter out = new PrintWriter(buffer);
+
+  public void beginJavaDocComment() {
+    out.println("/**");
+    indent();
+    indentPrefix = " * ";
+  }
+
+  /**
+   * This is a no-op.
+   */
+  public void commit(TreeLogger logger) {
+    out.flush();
+  }
+
+  public void endJavaDocComment() {
+    out.println("*/");
+    outdent();
+    indentPrefix = "";
+  }
+
+  public void indent() {
+    indentLevel++;
+  }
+
+  public void indentln(String s) {
+    indent();
+    println(s);
+    outdent();
+  }
+
+  public void outdent() {
+    indentLevel = Math.max(indentLevel - 1, 0);
+  }
+
+  public void print(String s) {
+    maybeIndent();
+    out.print(s);
+  }
+
+  public void println() {
+    maybeIndent();
+    out.println();
+    needsIndent = true;
+  }
+
+  public void println(String s) {
+    print(s);
+    println();
+  }
+
+  @Override
+  public String toString() {
+    out.flush();
+    return buffer.getBuffer().toString();
+  }
+
+  private void maybeIndent() {
+    if (needsIndent) {
+      needsIndent = false;
+      for (int i = 0; i < indentLevel; i++) {
+        out.print("  ");
+        out.print(indentPrefix);
+      }
+    }
+  }
+}
diff --git a/user/test/com/google/gwt/resources/ResourcesSuite.java b/user/test/com/google/gwt/resources/ResourcesSuite.java
new file mode 100644
index 0000000..79d9385
--- /dev/null
+++ b/user/test/com/google/gwt/resources/ResourcesSuite.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources;
+
+import com.google.gwt.junit.tools.GWTTestSuite;
+import com.google.gwt.resources.client.CSSResourceTest;
+import com.google.gwt.resources.client.ImageResourceTest;
+import com.google.gwt.resources.client.NestedBundleTest;
+import com.google.gwt.resources.client.TextResourceTest;
+import com.google.gwt.resources.rg.CssNodeClonerTest;
+import com.google.gwt.resources.rg.CssReorderTest;
+import com.google.gwt.resources.rg.CssRtlTest;
+
+import junit.framework.Test;
+
+/**
+ * Tests the ClientBundle framework.
+ */
+public class ResourcesSuite {
+  public static Test suite() {
+
+    GWTTestSuite suite = new GWTTestSuite("Test for com.google.gwt.resources");
+    suite.addTestSuite(CSSResourceTest.class);
+    suite.addTestSuite(CssReorderTest.class);
+    suite.addTestSuite(CssRtlTest.class);
+    suite.addTestSuite(CssNodeClonerTest.class);
+    suite.addTestSuite(ImageResourceTest.class);
+    suite.addTestSuite(NestedBundleTest.class);
+    suite.addTestSuite(TextResourceTest.class);
+
+    return suite;
+  }
+}
diff --git a/user/test/com/google/gwt/resources/client/16x16.png b/user/test/com/google/gwt/resources/client/16x16.png
new file mode 100644
index 0000000..77e06ba
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/16x16.png
Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/32x32.png b/user/test/com/google/gwt/resources/client/32x32.png
new file mode 100644
index 0000000..55af260
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/32x32.png
Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/64x64-dup.png b/user/test/com/google/gwt/resources/client/64x64-dup.png
new file mode 100644
index 0000000..e437adc
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/64x64-dup.png
Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/64x64.png b/user/test/com/google/gwt/resources/client/64x64.png
new file mode 100644
index 0000000..e437adc
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/64x64.png
Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/CSSResourceTest.java b/user/test/com/google/gwt/resources/client/CSSResourceTest.java
new file mode 100644
index 0000000..dca1c2d
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/CSSResourceTest.java
@@ -0,0 +1,279 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.junit.client.GWTTestCase;
+import com.google.gwt.resources.client.CssResource.Import;
+import com.google.gwt.resources.client.CssResource.ImportedWithPrefix;
+import com.google.gwt.resources.client.CssResource.Shared;
+import com.google.gwt.resources.client.CssResource.Strict;
+
+/**
+ * 
+ */
+public class CSSResourceTest extends GWTTestCase {
+
+  interface ConcatenatedResources extends ClientBundle {
+    @Source(value = {"concatenatedA.css", "concatenatedB.css"})
+    CssResource css();
+  }
+
+  interface CssWithDefines extends CssResource {
+    double lengthFloat();
+
+    int lengthInt();
+
+    double percentFloat();
+
+    int percentInt();
+
+    double rawDouble();
+
+    float rawFloat();
+
+    int rawInt();
+  }
+
+  interface MyCssResource extends CssResource, MyNonCssResource {
+    @ClassName("replacement-not-java-ident")
+    String nameOverride();
+  }
+
+  interface MyCssResourceA extends MyCssResource, SharedClasses {
+    String local();
+
+    // This shouldn't make a difference
+    String replacement();
+  }
+
+  @ImportedWithPrefix("gwt-MyCssResourceB")
+  interface MyCssResourceB extends MyCssResource, SharedClasses {
+    String local();
+
+    String sharedOverrideClass();
+  }
+
+  /*
+   * Check type inheritance.
+   */
+  interface MyCssResourceWithSprite extends MyCssResource {
+    String extraSpriteClass();
+
+    String multiClassA();
+
+    String multiClassB();
+  }
+
+  interface MyNonCssResource {
+    String nameOverride();
+
+    String replacement();
+  }
+
+  interface Resources extends ClientBundle {
+    Resources INSTANCE = GWT.create(Resources.class);
+
+    @Source("siblingTestA.css")
+    MyCssResourceA a();
+
+    @Source("siblingTestB.css")
+    MyCssResourceB b();
+
+    @Source("test.css")
+    MyCssResourceWithSprite css();
+
+    @Source("32x32.png")
+    DataResource dataMethod();
+
+    // Test default extensions
+    CssWithDefines deftest();
+
+    @Source("unrelatedDescendants.css")
+    @Import(value = {MyCssResourceA.class, MyCssResourceB.class})
+    @Strict
+    CssResource descendants();
+
+    @Source("16x16.png")
+    ImageResource spriteMethod();
+  }
+
+  interface SharedBase extends CssResource {
+    String unsharedClass();
+  }
+
+  @ImportedWithPrefix("gwt-Shared")
+  @Shared
+  interface SharedClasses extends SharedBase {
+    String sharedClass();
+
+    String sharedOverrideClass();
+  }
+
+  interface SiblingResources extends ClientBundle {
+    @Source("siblingTestA.css")
+    MyCssResourceA a();
+
+    @Source("siblingTestB.css")
+    MyCssResourceB b();
+  }
+
+  public static String red() {
+    return "orange";
+  }
+
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.resources.Resources";
+  }
+
+  public void report(String s) {
+    // Can be filled in if debugging.
+    System.out.println(s);
+  }
+
+  public void testConcatenatedResource() {
+    ConcatenatedResources r = GWT.create(ConcatenatedResources.class);
+    String text = r.css().getText();
+    assertTrue(text.contains(".partA"));
+    assertTrue(text.contains(".partB"));
+  }
+
+  public void testCss() {
+    MyCssResourceWithSprite css = Resources.INSTANCE.css();
+    String text = css.getText();
+    report(text);
+
+    // Check the sprite
+    assertTrue(text.contains("height:16px"));
+    assertTrue(text.contains("width:16px"));
+
+    // Check the value() expansion
+    assertTrue(text.contains("offset-left:\"guard\" 16px !important;"));
+    assertTrue(text.contains("offset:16px 16px;"));
+
+    // Make sure renaming works
+    assertFalse("replacement".equals(css.replacement()));
+    assertTrue(text.contains("." + css.replacement()));
+    assertTrue(text.contains("." + css.replacement() + ":after"));
+    assertTrue(text.contains("." + css.nameOverride()));
+
+    // Make sure renaming for multi-class selectors (.foo.bar) works
+    assertFalse("multiClassA".equals(css.multiClassA()));
+    assertFalse("multiClassB".equals(css.multiClassB()));
+    assertTrue(text.contains("." + css.multiClassA() + "." + css.multiClassB()));
+
+    // Check static if evaluation
+    assertTrue(text.contains("static:PASSED;"));
+    assertFalse(text.contains("FAIL"));
+
+    // Check runtime if evaluation
+    assertTrue(text.contains("runtime:PASSED;"));
+
+    // Check interestingly-named idents
+    assertTrue(text.contains("\\-some-wacky-extension"));
+    assertTrue(text.contains(".ns\\:tag"));
+    assertTrue(text.contains(".ns\\:tag:pseudo"));
+
+    // Check escaped string values
+    assertTrue(text.contains("\"Hello\\\\\\\" world\""));
+
+    // Check values
+    assertFalse(text.contains("0.0;"));
+    assertFalse(text.contains("0.0px;"));
+    assertFalse(text.contains("0px;"));
+    assertTrue(text.contains("background-color:#fff;"));
+    assertTrue(text.contains("content:\"bar\";"));
+
+    // Check invalid CSS values
+    assertTrue(text.contains("top:expression(document.compatMode==\"CSS1Compat\" ? documentElement.scrollTop:document.body.scrollTop \\ 2);"));
+
+    // Check data URL expansion
+    assertTrue(text.contains(Resources.INSTANCE.dataMethod().getUrl()));
+
+    // Check @eval expansion
+    assertTrue(text.contains(red() + ";"));
+
+    // Check @def substitution
+    assertTrue(text.contains("50px"));
+
+    // Check merging semantics
+    assertTrue(text.indexOf("static:PASSED") < text.indexOf("runtime:PASSED"));
+    assertTrue(text.indexOf("before:merge") != -1);
+    assertTrue(text.indexOf("before:merge") < text.indexOf("after:merge"));
+    assertTrue(text.indexOf(".may-combine,.may-combine2") != -1);
+    assertTrue(text.indexOf("merge:merge") != -1);
+    assertTrue(text.indexOf("merge:merge") < text.indexOf("may-not-combine"));
+    assertTrue(text.indexOf("may-not-combine") < text.indexOf("prevent:true"));
+    assertTrue(text.indexOf("prevent:true") < text.indexOf("prevent-merge:true"));
+    assertTrue(text.indexOf("prevent:true") < text.indexOf("may-not-combine2"));
+
+    // Check commonly-used CSS3 constructs
+    assertTrue(text.contains("background-color:rgba(0,0,0,0.5);"));
+  }
+
+  public void testDefines() {
+    Resources r = GWT.create(Resources.class);
+    CssWithDefines defines = r.deftest();
+
+    assertEquals(1, defines.rawInt());
+    assertEquals(1.5F, defines.rawFloat());
+    assertEquals(1.5, defines.rawDouble());
+
+    assertEquals(50, defines.lengthInt());
+    assertEquals(1.5, defines.lengthFloat());
+
+    assertEquals(50, defines.percentInt());
+    assertEquals(50.5, defines.percentFloat());
+  }
+
+  public void testMultipleBundles() {
+    Resources r1 = GWT.create(Resources.class);
+    SiblingResources r2 = GWT.create(SiblingResources.class);
+
+    assertEquals(r1.a().replacement(), r2.a().replacement());
+    assertEquals(r1.b().replacement(), r2.b().replacement());
+
+    assertEquals(r1.a().sharedClass(), r2.b().sharedClass());
+    assertFalse(r1.a().sharedOverrideClass().equals(
+        r2.b().sharedOverrideClass()));
+    assertFalse(r1.a().unsharedClass().equals(r2.b().unsharedClass()));
+
+    String text = r1.descendants().getText();
+    report(text);
+    assertTrue(text.contains("." + r1.a().local() + " ." + r1.b().local()));
+  }
+
+  public void testSiblingCSS() {
+    SiblingResources r = GWT.create(SiblingResources.class);
+
+    assertFalse(r.a().replacement().equals(r.b().replacement()));
+    assertFalse(r.a().local().equals(r.b().local()));
+
+    String a = r.a().getText();
+    String b = r.b().getText();
+
+    report(a);
+    report(b);
+
+    assertTrue(a.contains(".other"));
+    assertTrue(b.contains(".other"));
+    assertTrue(a.contains(r.a().local()));
+    assertTrue(b.contains(r.b().local()));
+    assertFalse(a.contains(r.b().local()));
+    assertFalse(b.contains(r.a().local()));
+  }
+}
diff --git a/user/test/com/google/gwt/resources/client/ImageResourceTest.java b/user/test/com/google/gwt/resources/client/ImageResourceTest.java
new file mode 100644
index 0000000..982af95
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/ImageResourceTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.event.dom.client.ErrorEvent;
+import com.google.gwt.event.dom.client.ErrorHandler;
+import com.google.gwt.event.dom.client.LoadEvent;
+import com.google.gwt.event.dom.client.LoadHandler;
+import com.google.gwt.junit.client.GWTTestCase;
+import com.google.gwt.resources.client.ImageResource.ImageOptions;
+import com.google.gwt.resources.client.ImageResource.RepeatStyle;
+import com.google.gwt.user.client.ui.Image;
+import com.google.gwt.user.client.ui.RootPanel;
+
+/**
+ * Tests ImageResource generation.
+ */
+public class ImageResourceTest extends GWTTestCase {
+  static interface Resources extends ClientBundle {
+    @Source("16x16.png")
+    ImageResource i16x16();
+
+    @Source("16x16.png")
+    @ImageOptions(repeatStyle = RepeatStyle.Horizontal)
+    ImageResource i16x16Horizontal();
+
+    @Source("16x16.png")
+    @ImageOptions(repeatStyle = RepeatStyle.Vertical)
+    ImageResource i16x16Vertical();
+
+    @Source("32x32.png")
+    ImageResource i32x32();
+
+    @Source("32x32.png")
+    @ImageOptions(repeatStyle = RepeatStyle.Horizontal)
+    ImageResource i32x32Horizontal();
+
+    @Source("32x32.png")
+    @ImageOptions(repeatStyle = RepeatStyle.Vertical)
+    ImageResource i32x32Vertical();
+
+    @Source("64x64.png")
+    ImageResource i64x64();
+
+    @Source("64x64.png")
+    ImageResource i64x64Dup();
+
+    @Source("64x64-dup.png")
+    ImageResource i64x64Dup2();
+
+    // Test default filename lookup while we're at it
+    ImageResource largeLossless();
+
+    // Test default filename lookup while we're at it
+    ImageResource largeLossy();
+  }
+
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.resources.Resources";
+  }
+
+  public void testDedup() {
+    Resources r = GWT.create(Resources.class);
+
+    ImageResource a = r.i64x64();
+    ImageResource b = r.i64x64Dup();
+    ImageResource c = r.i64x64Dup2();
+    assertEquals(64, a.getHeight());
+    assertEquals(64, a.getWidth());
+
+    assertEquals(a.getLeft(), b.getLeft());
+    assertEquals(a.getLeft(), c.getLeft());
+
+    assertEquals(a.getLeft(), b.getTop());
+    assertEquals(a.getLeft(), c.getTop());
+
+    // See if the size of the image strip is what we expect
+    Image i = new Image(a.getURL());
+    i.addLoadHandler(new LoadHandler() {
+      public void onLoad(LoadEvent event) {
+        finishTest();
+      }
+    });
+    i.addErrorHandler(new ErrorHandler() {
+      public void onError(ErrorEvent event) {
+        fail("ErrorEvent");
+      }
+    });
+
+    RootPanel.get().add(i);
+    delayTestFinish(500);
+  }
+
+  public void testPacking() {
+    Resources r = GWT.create(Resources.class);
+
+    ImageResource i64 = r.i64x64();
+    ImageResource lossy = r.largeLossy();
+    ImageResource lossless = r.largeLossless();
+
+    // The large, lossless image should be bundled
+    if (!i64.getURL().startsWith("data:")) {
+      assertEquals(i64.getURL(), lossless.getURL());
+    }
+
+    // Make sure that the large, lossy image isn't bundled with the rest
+    assertTrue(!i64.getURL().equals(lossy.getURL()));
+
+    assertEquals(16, r.i16x16Vertical().getWidth());
+    assertEquals(16, r.i16x16Vertical().getHeight());
+
+    assertEquals(16, r.i16x16Horizontal().getWidth());
+    assertEquals(16, r.i16x16Horizontal().getHeight());
+  }
+}
diff --git a/user/test/com/google/gwt/resources/client/NestedBundleTest.java b/user/test/com/google/gwt/resources/client/NestedBundleTest.java
new file mode 100644
index 0000000..09efa3d
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/NestedBundleTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.junit.client.GWTTestCase;
+import com.google.gwt.resources.client.GwtCreateResource.ClassType;
+
+/**
+ * Verify that nested bundles work correctly.
+ */
+public class NestedBundleTest extends GWTTestCase {
+
+  interface NestedBundle extends ClientBundle {
+    @Source("hello.txt")
+    TextResource hello();
+
+    NestedBundle nested();
+
+    GwtCreateResource<NestedBundle> nestedCreate();
+
+    @ClassType(NestedBundle.class)
+    GwtCreateResource<Object> nestedCreateWithOverride();
+  }
+
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.resources.Resources";
+  }
+
+  public void testNestedBundle() {
+    NestedBundle b = GWT.create(NestedBundle.class);
+    assertSame(b.hello(), b.nested().hello());
+  }
+
+  public void testNestedCreate() {
+    NestedBundle b = GWT.create(NestedBundle.class);
+    NestedBundle q = b.nestedCreate().create();
+    NestedBundle r = b.nestedCreate().create();
+    assertNotSame(q, r);
+
+    assertSame(q.hello(), r.hello());
+  }
+
+  public void testNestedCreateOverride() {
+    NestedBundle b = GWT.create(NestedBundle.class);
+    Object o = b.nestedCreateWithOverride().create();
+    assertTrue(o instanceof NestedBundle);
+  }
+}
diff --git a/user/test/com/google/gwt/resources/client/TextResourceTest.java b/user/test/com/google/gwt/resources/client/TextResourceTest.java
new file mode 100644
index 0000000..ffeaca8
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/TextResourceTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.junit.client.GWTTestCase;
+
+/**
+ * Tests for TextResource assembly and use.
+ */
+public class TextResourceTest extends GWTTestCase {
+
+  private static final String HELLO = "Hello World!";
+
+  static interface Resources extends ClientBundleWithLookup {
+    @Source("com/google/gwt/resources/client/hello.txt")
+    TextResource helloWorldAbsolute();
+
+    @Source("hello.txt")
+    ExternalTextResource helloWorldExternal();
+
+    @Source("hello.txt")
+    TextResource helloWorldRelative();
+  }
+
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.resources.Resources";
+  }
+
+  public void testExternal() throws ResourceException {
+    final Resources r = GWT.create(Resources.class);
+
+    ResourceCallback<TextResource> c = new ResourceCallback<TextResource>() {
+
+      public void onError(ResourceException e) {
+        e.printStackTrace();
+        fail("Unable to fetch " + e.getResource().getName());
+      }
+
+      public void onSuccess(TextResource resource) {
+        assertEquals(r.helloWorldExternal().getName(), resource.getName());
+        assertEquals(HELLO, resource.getText());
+        finishTest();
+      }
+    };
+
+    r.helloWorldExternal().getText(c);
+    delayTestFinish(2000);
+  }
+
+  public void testInline() {
+    Resources r = GWT.create(Resources.class);
+    assertEquals(HELLO, r.helloWorldRelative().getText());
+    assertEquals(HELLO, r.helloWorldAbsolute().getText());
+  }
+
+  public void testMeta() {
+    Resources r = GWT.create(Resources.class);
+    assertEquals("helloWorldAbsolute", r.helloWorldAbsolute().getName());
+    assertEquals("helloWorldRelative", r.helloWorldRelative().getName());
+    assertEquals("helloWorldExternal", r.helloWorldExternal().getName());
+
+    ResourcePrototype[] resources = r.getResources();
+    assertEquals(3, resources.length);
+  }
+}
diff --git a/user/test/com/google/gwt/resources/client/concatenatedA.css b/user/test/com/google/gwt/resources/client/concatenatedA.css
new file mode 100644
index 0000000..6b1c69e
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/concatenatedA.css
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+.partA {
+  background: blue;
+}
\ No newline at end of file
diff --git a/user/test/com/google/gwt/resources/client/concatenatedB.css b/user/test/com/google/gwt/resources/client/concatenatedB.css
new file mode 100644
index 0000000..f0b53db
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/concatenatedB.css
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+.partB {
+  background: blue;
+}
\ No newline at end of file
diff --git a/user/test/com/google/gwt/resources/client/deftest.css b/user/test/com/google/gwt/resources/client/deftest.css
new file mode 100644
index 0000000..0db8a81
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/deftest.css
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+ @def rawInt 1;
+ @def rawFloat 1.5;
+ @def rawDouble 1.5;
+ 
+ @def percentInt 50%;
+ @def percentFloat 50.5%;
+ 
+ @def lengthInt 50px;
+ @def lengthFloat 1.5px;
\ No newline at end of file
diff --git a/user/test/com/google/gwt/resources/client/hello.txt b/user/test/com/google/gwt/resources/client/hello.txt
new file mode 100644
index 0000000..c57eff5
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/hello.txt
@@ -0,0 +1 @@
+Hello World!
\ No newline at end of file
diff --git a/user/test/com/google/gwt/resources/client/largeLossless.png b/user/test/com/google/gwt/resources/client/largeLossless.png
new file mode 100644
index 0000000..ca911e1
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/largeLossless.png
Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/largeLossy.jpg b/user/test/com/google/gwt/resources/client/largeLossy.jpg
new file mode 100644
index 0000000..398e08e
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/largeLossy.jpg
Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/siblingTestA.css b/user/test/com/google/gwt/resources/client/siblingTestA.css
new file mode 100644
index 0000000..9a6711e
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/siblingTestA.css
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* This is the first half of the sibling test. */
+.replacement { background:red; }
+.replacement-not-java-ident {color: blue;}
+.local {background: green; }
+.other {background: blue; }
+.unsharedClass {}
+.sharedClass {}
+.sharedOverrideClass {}
diff --git a/user/test/com/google/gwt/resources/client/siblingTestB.css b/user/test/com/google/gwt/resources/client/siblingTestB.css
new file mode 100644
index 0000000..15f05f1
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/siblingTestB.css
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* This is the other half of the sibling test. */
+.other {background: blue; }
+.replacement-not-java-ident {color: blue;}
+.replacement { background:red; }
+.local {background:green;}
+.unsharedClass {}
+.sharedClass {}
+.sharedOverrideClass {}
diff --git a/user/test/com/google/gwt/resources/client/test.css b/user/test/com/google/gwt/resources/client/test.css
new file mode 100644
index 0000000..ad420a5
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/test.css
@@ -0,0 +1,210 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+@def BIG 50px;
+@def DIRECTION ltr;
+@eval RED com.google.gwt.resources.client.CSSResourceTest.red();
+@url BACKGROUND dataMethod;
+
+/* Check @def expansion */
+@def SPRITEWIDTH value("spriteMethod.getWidth", "px");
+@def SPRITESIZE SPRITEWIDTH value("spriteMethod.getHeight", "px");
+
+/*
+ * We'll use the token FAIL to indicate text that should never be seen in the output.
+ */
+
+/* Test @sprite expansion */
+@sprite .spriteClass, .extraSpriteClass {
+  gwt-image: "spriteMethod";
+  more: properties;
+}
+
+.affectedBySprite {
+    offset-left: "guard" SPRITEWIDTH !important;
+    offset: SPRITESIZE;
+}
+
+.blahA {
+	background-color: #000;
+}
+
+.blahA[someAttribute="foo"][beer="baz"] {
+	background-color: #fff;
+}
+
+/* Test value substitution */
+div {
+    border: BIG solid RED;
+    direction: DIRECTION;
+    background: BACKGROUND;
+}
+
+div[foo="bar"] {
+    content: 'bar';
+}
+
+/* Test structural modifications */
+@if (false) {
+  div {
+    runtime: FAIL;
+  }
+} @elif (true) {
+  div {
+    runtime: PASSED;
+  }
+} @else {
+  div {
+    runtime: FAIL;
+  }
+}
+
+@if CssResource.style obf OBF {
+  div {
+    static: PASSED;
+  }
+} @elif CssResource.style pretty PRETTY {
+  div {
+    static: PASSED;
+  }
+} @else {
+  div {
+    static: FAIL;
+  }
+}
+
+/* Test named classes */
+.replacement {
+  color: red;
+}
+
+.replacement:after {
+  content: "Hello\\\" world";
+}
+
+.replacement-not-java-ident {
+  color: blue;
+}
+
+/* Test unusual tag, class, and property names and values */
+div {
+  \-some-wacky-extension : boo;
+  another-extension: \-bar;
+}
+
+div {
+  filter: "alpha(opacity = 30)";
+}
+
+div-with-literal {
+  top: literal("expression(document.compatMode==\"CSS1Compat\" ? documentElement.scrollTop:document.body.scrollTop \\ 2)");
+}
+
+.ns\:tag {
+  border: red;
+}
+
+.ns\:tag:pseudo {
+  content : "blah";
+}
+
+/* Test merging / promotion functions*/
+
+.may-merge {
+  border: 0;
+}
+
+.may-combine {
+  border: 0;
+}
+
+/* Test merging around empty rules */
+.FAIL {}
+
+/* Make sure rules in @if and @media are respected */
+@media blah {
+  @if (true) {
+    .this-does-not-matter {
+      after: merge;
+    }
+  }
+}
+
+.may-merge {
+  before: merge;
+}
+
+.may-combine2 {
+  border: 0;
+}
+
+.may-not-merge {
+  merge: merge;
+}
+
+.may-not-combine {
+  combine: combine;
+  prevent-combine: true;
+}
+
+/* Make sure rules in @if and @media are respected */
+@media blah {
+  @if (true) {
+    .may-not-merge-or-combine-because-of-this {
+      prevent: true;
+    }
+  }
+}
+.may-not-merge {
+  prevent-merge: true;
+}
+
+.may-not-combine2 {
+  combine: combine;
+  prevent-combine: true;
+}
+
+/* Ensure preservation of standard @rules */
+
+@MEDIA print {
+  div {
+    media: no-merge;
+  }
+}
+
+@page {
+  margin: 3cm;
+}
+
+@page :left {
+  margin: 4cm;
+}
+
+/* Ensure multi-class selectors fully obfuscate */
+.multiClassA {
+  border: 1px solid red;
+}
+
+.multiClassB {
+  border: 1px solid blue;
+}
+
+.multiClassA.multiClassB {
+  border: 1px solid blue;
+}
+
+.css3Color {
+  background-color: rgba(0, 0, 0, 0.5); 
+}
diff --git a/user/test/com/google/gwt/resources/client/unrelatedDescendants.css b/user/test/com/google/gwt/resources/client/unrelatedDescendants.css
new file mode 100644
index 0000000..637f3fc
--- /dev/null
+++ b/user/test/com/google/gwt/resources/client/unrelatedDescendants.css
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+/* No @ImportWithPrefix followed by one with the annotation */
+.MyCssResourceA-local .gwt-MyCssResourceB-local {
+  background: green;
+}
diff --git a/user/test/com/google/gwt/resources/rg/CssNodeClonerTest.java b/user/test/com/google/gwt/resources/rg/CssNodeClonerTest.java
new file mode 100644
index 0000000..24c5042
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/CssNodeClonerTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.resources.css.GenerateCssAst;
+import com.google.gwt.resources.css.ast.CssNode;
+import com.google.gwt.resources.css.ast.CssNodeCloner;
+import com.google.gwt.resources.css.ast.CssProperty;
+import com.google.gwt.resources.css.ast.CssSelector;
+import com.google.gwt.resources.css.ast.CssStylesheet;
+
+import java.net.URL;
+import java.util.List;
+
+/**
+ * Tests the CssNodeCloner utility class.
+ */
+public class CssNodeClonerTest extends CssTestCase {
+
+  public void testClone() throws UnableToCompleteException {
+    CssStylesheet sheet = GenerateCssAst.exec(TreeLogger.NULL,
+        new URL[] {getClass().getClassLoader().getResource(
+            "com/google/gwt/resources/client/test.css")});
+
+    CssStylesheet cloned = CssNodeCloner.clone(CssStylesheet.class, sheet);
+
+    assertNotSame(sheet, cloned);
+    assertNoAliasing(cloned);
+  }
+
+  public void testCloneList() throws UnableToCompleteException {
+    CssStylesheet sheet = GenerateCssAst.exec(TreeLogger.NULL,
+        new URL[] {getClass().getClassLoader().getResource(
+            "com/google/gwt/resources/client/test.css")});
+
+    List<CssNode> cloned = CssNodeCloner.clone(CssNode.class, sheet.getNodes());
+
+    assertEquals(sheet.getNodes().size(), cloned.size());
+
+    for (CssNode node : cloned) {
+      assertNoAliasing(node);
+    }
+  }
+
+  public void testCloneProperty() {
+    CssProperty.IdentValue value = new CssProperty.IdentValue("value");
+    CssProperty p = new CssProperty("name", value, true);
+
+    CssProperty clone = CssNodeCloner.clone(CssProperty.class, p);
+
+    assertNotSame(p, clone);
+    assertEquals(p.getName(), clone.getName());
+    assertEquals(value.getIdent(),
+        clone.getValues().getValues().get(0).isIdentValue().getIdent());
+  }
+
+  public void testCloneSelector() {
+    CssSelector sel = new CssSelector("a , b");
+
+    CssSelector clone = CssNodeCloner.clone(CssSelector.class, sel);
+
+    assertNotSame(sel, clone);
+    assertEquals(sel.getSelector(), clone.getSelector());
+  }
+}
diff --git a/user/test/com/google/gwt/resources/rg/CssReorderTest.java b/user/test/com/google/gwt/resources/rg/CssReorderTest.java
new file mode 100644
index 0000000..2777548
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/CssReorderTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.resources.css.ast.CssVisitor;
+import com.google.gwt.resources.rg.CssResourceGenerator.MergeIdenticalSelectorsVisitor;
+import com.google.gwt.resources.rg.CssResourceGenerator.MergeRulesByContentVisitor;
+import com.google.gwt.resources.rg.CssResourceGenerator.SplitRulesVisitor;
+
+/**
+ * Tests CSS reordering visitors.
+ */
+public class CssReorderTest extends CssTestCase {
+  public void testPropertyMerging() throws UnableToCompleteException {
+    test(TreeLogger.NULL, "propertyMerging", false, makeVisitors());
+  }
+
+  public void testSelectorMerging() throws UnableToCompleteException {
+    test(TreeLogger.NULL, "selectorMerging", false, makeVisitors());
+  }
+
+  private CssVisitor[] makeVisitors() {
+    return new CssVisitor[] {
+        new SplitRulesVisitor(), new AliasDetector(),
+        new MergeIdenticalSelectorsVisitor(), new AliasDetector(),
+        new MergeRulesByContentVisitor(), new AliasDetector()};
+  }
+}
diff --git a/user/test/com/google/gwt/resources/rg/CssRtlTest.java b/user/test/com/google/gwt/resources/rg/CssRtlTest.java
new file mode 100644
index 0000000..ac0bc8e
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/CssRtlTest.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.resources.css.ast.CssVisitor;
+import com.google.gwt.resources.rg.CssResourceGenerator.RtlVisitor;
+
+/**
+ * This is a static test of the automatic RTL support.
+ */
+public class CssRtlTest extends CssTestCase {
+  public void testBackgroundProperties() throws UnableToCompleteException {
+    test(TreeLogger.NULL, "backgroundProperties", true, makeVisitors());
+  }
+
+  public void testCursorProperties() throws UnableToCompleteException {
+    test(TreeLogger.NULL, "cursorProperties", true, makeVisitors());
+  }
+
+  public void testDirectionUpdatedInBodyOnly() throws UnableToCompleteException {
+    test(TreeLogger.NULL, "directionProperty", true, makeVisitors());
+  }
+
+  public void testFourValuedProperties() throws UnableToCompleteException {
+    test(TreeLogger.NULL, "fourValuedProperties", true, makeVisitors());
+  }
+
+  public void testLeftRightProperties() throws UnableToCompleteException {
+    test(TreeLogger.NULL, "leftRightProperties", true, makeVisitors());
+  }
+
+  public void testNoFlip() throws UnableToCompleteException {
+    test(TreeLogger.NULL, "noflip", true, makeVisitors());
+  }
+
+  private CssVisitor[] makeVisitors() {
+    return new CssVisitor[] {new RtlVisitor(), new AliasDetector()};
+  }
+}
diff --git a/user/test/com/google/gwt/resources/rg/CssTestCase.java b/user/test/com/google/gwt/resources/rg/CssTestCase.java
new file mode 100644
index 0000000..d66d66c
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/CssTestCase.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.GeneratorContext;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.resources.css.GenerateCssAst;
+import com.google.gwt.resources.css.ast.CssNode;
+import com.google.gwt.resources.css.ast.CssStylesheet;
+import com.google.gwt.resources.css.ast.CssVisitor;
+import com.google.gwt.resources.css.ast.HasNodes;
+import com.google.gwt.resources.ext.ResourceContext;
+
+import junit.framework.TestCase;
+
+import java.net.URL;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Contains functions for golden-output tests that are concerned with structural
+ * modifications to the CSS AST.
+ */
+class CssTestCase extends TestCase {
+
+  /**
+   * Triggers an assertion if a CssNode is traversed more than once.
+   * 
+   * @see CssTestCase#assertNoAliasing(CssNode)
+   */
+  protected static class AliasDetector extends CssVisitor {
+    private final Map<CssNode, Void> seen = new IdentityHashMap<CssNode, Void>();
+
+    @Override
+    protected void doAccept(List<? extends CssNode> list) {
+      for (CssNode node : list) {
+        doAccept(node);
+      }
+    }
+
+    @Override
+    protected void doAcceptWithInsertRemove(List<? extends CssNode> list) {
+      for (CssNode node : list) {
+        doAccept(node);
+      }
+    }
+
+    @Override
+    protected <T extends CssNode> T doAccept(T node) {
+      assertFalse("Found repeated node " + node.toString(),
+          seen.containsKey(node));
+      seen.put(node, null);
+      return super.doAccept(node);
+    }
+  }
+
+  /**
+   * Total fake, no implementations.
+   */
+  private static class FakeContext implements ResourceContext {
+    public String deploy(String suggestedFileName, String mimeType,
+        byte[] data, boolean xhrCompatible) throws UnableToCompleteException {
+      return null;
+    }
+
+    public String deploy(URL resource, boolean xhrCompatible)
+        throws UnableToCompleteException {
+      return null;
+    }
+
+    public GeneratorContext getGeneratorContext() {
+      return null;
+    }
+
+    public String getImplementationSimpleSourceName()
+        throws IllegalStateException {
+      return null;
+    }
+
+    public JClassType getClientBundleType() {
+      return null;
+    }
+
+    public boolean supportsDataUrls() {
+      return true;
+    }
+  }
+
+  /**
+   * Asserts that two CssNodes are identical.
+   */
+  protected static <T extends CssNode & HasNodes> void assertEquals(
+      TreeLogger logger, T expected, T test) throws UnableToCompleteException {
+    String expectedCss = CssResourceGenerator.makeExpression(logger,
+        new FakeContext(), null, expected, false);
+    String testCss = CssResourceGenerator.makeExpression(logger,
+        new FakeContext(), null, test, false);
+    assertEquals(expectedCss, testCss);
+  }
+
+  /**
+   * Ensure that no CssNode is traversed more than once due to AST errors.
+   */
+  protected static void assertNoAliasing(CssNode node) {
+    (new AliasDetector()).accept(node);
+  }
+
+  /**
+   * Compares the generated Java expressions for an input file, transformed in
+   * order by the specified visitors, and a golden-output file.
+   */
+  private static void test(TreeLogger logger, URL test, URL expected,
+      CssVisitor... visitors) throws UnableToCompleteException {
+
+    CssStylesheet expectedSheet = null;
+    CssStylesheet testSheet = null;
+
+    try {
+      expectedSheet = GenerateCssAst.exec(logger, new URL[] {expected});
+      testSheet = GenerateCssAst.exec(logger, new URL[] {test});
+    } catch (UnableToCompleteException e) {
+      fail("Unable to parse stylesheet");
+    }
+
+    for (CssVisitor v : visitors) {
+      v.accept(testSheet);
+    }
+
+    assertEquals(logger, expectedSheet, testSheet);
+  }
+
+  /**
+   * Runs a test.
+   * 
+   * @param testName is used to compute the test and expected resource paths.
+   * @param reversible if <code>true</code>, the test will attempt to transform
+   *          the expected css into the test css
+   */
+  protected void test(TreeLogger logger, String testName, boolean reversible,
+      CssVisitor... visitors) throws UnableToCompleteException {
+    String packagePath = getClass().getPackage().getName().replace('.', '/')
+        + "/";
+    URL testUrl = getClass().getClassLoader().getResource(
+        packagePath + testName + "_test.css");
+    assertNotNull("Cauld not find testUrl", testUrl);
+    URL expectedUrl = getClass().getClassLoader().getResource(
+        packagePath + testName + "_expected.css");
+    assertNotNull("Cauld not find testUrl", expectedUrl);
+
+    test(logger, testUrl, expectedUrl, visitors);
+
+    if (reversible) {
+      test(logger, expectedUrl, testUrl, visitors);
+    }
+  }
+}
diff --git a/user/test/com/google/gwt/resources/rg/backgroundProperties_expected.css b/user/test/com/google/gwt/resources/rg/backgroundProperties_expected.css
new file mode 100644
index 0000000..ed77a6f
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/backgroundProperties_expected.css
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* Tests swapping background positions */
+.selector1 {
+  background-position-x: 60%;
+}
+
+.selector2 {
+  background-position-x: right;
+}
+
+.selector3 {
+  background-position-x: left;
+}
+
+.selector4 {
+  background-position: 60% 40%;
+}
+
+.selector5 {
+  background-position: right top;
+}
+
+.selector6 {
+  background-position: top left;
+}
+
+.selector7 {
+  background: url("chess.png") gray 60% repeat fixed;
+}
+
+/* Reported NPE bug */
+.selector8 {
+    background-position: 0 0;
+}
+
+/* Tests below here should be unchanged */
+
+.selector10 {
+  background-position-x: auto;
+}
+
+.selector11 {
+  background-position-x: center;
+}
+
+.selector12 {
+  background-position-y: 0;
+}
+
+.selector13 {
+  background-position: 10px 40%;
+}
+
+.selector14 {
+  background: url("chess.png") gray left 40% repeat fixed;
+}
+
+/* This probably isn't valid, but try it anyway */
+.selector15 {
+  background: url("chess.png") gray center 40% left repeat fixed;
+}
+
diff --git a/user/test/com/google/gwt/resources/rg/backgroundProperties_test.css b/user/test/com/google/gwt/resources/rg/backgroundProperties_test.css
new file mode 100644
index 0000000..9d3dd68
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/backgroundProperties_test.css
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* Tests swapping background positions */
+.selector1 {
+  background-position-x: 40%;
+}
+
+.selector2 {
+  background-position-x: left;
+}
+
+/* This isn't a defined property, but it appears to be in common use */
+.selector3 {
+  background-position-x: right;
+}
+
+.selector4 {
+  background-position: 40% 40%;
+}
+
+.selector5 {
+  background-position: left top;
+}
+
+.selector6 {
+  background-position: top right;
+}
+
+.selector7 {
+  background: url("chess.png") gray 40% repeat fixed;
+}
+
+/* Reported NPE bug */
+.selector8 {
+    background-position: 0 0;
+}
+
+/* Tests below here should be unchanged */
+
+.selector10 {
+  background-position-x: auto;
+}
+
+.selector11 {
+  background-position-x: center;
+}
+
+.selector12 {
+  background-position-y: 0;
+}
+
+.selector13 {
+  background-position: 10px 40%;
+}
+
+.selector14 {
+  background: url("chess.png") gray right 40% repeat fixed;
+}
+
+/* This probably isn't valid, but try it anyway */
+.selector15 {
+  background: url("chess.png") gray center 40% right repeat fixed;
+}
diff --git a/user/test/com/google/gwt/resources/rg/cursorProperties_expected.css b/user/test/com/google/gwt/resources/rg/cursorProperties_expected.css
new file mode 100644
index 0000000..1ccd0ec
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/cursorProperties_expected.css
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* Tests swapping cursor directions */
+.selector {
+  cursor: nw-resize;
+}
+
+.selector2 {
+  cursor: w-resize;
+}
+
+.selector3 {
+  cursor: sw-resize;
+}
+
+.selector4 {
+  cursor: se-resize;
+}
+.selector5 {
+  cursor: e-resize;
+}
+
+.selector6 {
+  cursor: ne-resize;
+}
+
+/* Below should be unchanged */
+.selector10 {
+  cursor: be-resize;
+}
+
+.selector11 {
+  cursor: z-resize;
+}
+
+.selector12 {
+  cursor: inherit;
+}
+
+.selector13 {
+  cursor: no-resize;
+}
diff --git a/user/test/com/google/gwt/resources/rg/cursorProperties_test.css b/user/test/com/google/gwt/resources/rg/cursorProperties_test.css
new file mode 100644
index 0000000..39ed82f
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/cursorProperties_test.css
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* Tests swapping cursor directions */
+.selector {
+  cursor: ne-resize;
+}
+
+.selector2 {
+  cursor: e-resize;
+}
+
+.selector3 {
+  cursor: se-resize;
+}
+
+.selector4 {
+  cursor: sw-resize;
+}
+.selector5 {
+  cursor: w-resize;
+}
+
+.selector6 {
+  cursor: nw-resize;
+}
+
+/* Below should be unchanged */
+.selector10 {
+  cursor: be-resize;
+}
+
+.selector11 {
+  cursor: z-resize;
+}
+
+.selector12 {
+  cursor: inherit;
+}
+
+.selector13 {
+  cursor: no-resize;
+}
diff --git a/user/test/com/google/gwt/resources/rg/directionProperty_expected.css b/user/test/com/google/gwt/resources/rg/directionProperty_expected.css
new file mode 100644
index 0000000..6be29cd
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/directionProperty_expected.css
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* Only the direction property in the body selector should be updated. */
+body {
+  direction: rtl;
+}
+
+/* These should be unchanged */
+
+.selector1 {
+  direction: ltr;
+}
+
+body .selector2 {
+  direction: rtl:
+}
+
+* {
+  direction: inherit;
+}
diff --git a/user/test/com/google/gwt/resources/rg/directionProperty_test.css b/user/test/com/google/gwt/resources/rg/directionProperty_test.css
new file mode 100644
index 0000000..b137e14
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/directionProperty_test.css
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* Only the direction property in the body selector should be updated. */
+body {
+  direction: ltr;
+}
+
+/* These should be unchanged */
+
+.selector1 {
+  direction: ltr;
+}
+
+body .selector2 {
+  direction: rtl:
+}
+
+* {
+  direction: inherit;
+}
diff --git a/user/test/com/google/gwt/resources/rg/fourValuedProperties_expected.css b/user/test/com/google/gwt/resources/rg/fourValuedProperties_expected.css
new file mode 100644
index 0000000..0ab4b4e
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/fourValuedProperties_expected.css
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* Tests border and margin properties with four values */
+.selector1 {
+  padding: 1px 4px 3px 2px;
+  margin: 1px 4px 3px 2px;
+}
+
+.selector2 {
+  padding: 1px inherit 3px auto;
+  margin: 1px auto 3px inherit;
+}
+
+.selector3 {
+  padding: 1px 'string' 3px 2px;
+}
+
+.selector4 {
+  border-color: red yellow blue green;
+  border-style: solid double dashed dotted;
+  border-width: thin 0 thick medium;
+}
+
+/* Nothing below here should be changed */
+.selector10 {
+  padding: 1px 2px 3px;
+}
+
+.selector11 {
+  padding: 1px 2px;
+}
+
+.selector12 {
+  padding: 1px;
+}
+
+.selector13 {
+  border: thin solid red collapse;
+}
diff --git a/user/test/com/google/gwt/resources/rg/fourValuedProperties_test.css b/user/test/com/google/gwt/resources/rg/fourValuedProperties_test.css
new file mode 100644
index 0000000..ea7c2e7
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/fourValuedProperties_test.css
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* Tests border and margin properties with four values */
+.selector1 {
+  padding: 1px 2px 3px 4px;
+  margin: 1px 2px 3px 4px;
+}
+
+.selector2 {
+  padding: 1px auto 3px inherit;
+  margin: 1px inherit 3px auto;
+}
+
+.selector3 {
+  padding: 1px 2px 3px 'string';
+}
+
+.selector4 {
+  border-color: red green blue yellow;
+  border-style: solid dotted dashed double;
+  border-width: thin medium thick 0;
+}
+
+/* Nothing below here should be changed */
+.selector10 {
+  padding: 1px 2px 3px;
+}
+
+.selector11 {
+  padding: 1px 2px;
+}
+
+.selector12 {
+  padding: 1px;
+}
+
+.selector13 {
+  border: thin solid red collapse;
+}
diff --git a/user/test/com/google/gwt/resources/rg/leftRightProperties_expected.css b/user/test/com/google/gwt/resources/rg/leftRightProperties_expected.css
new file mode 100644
index 0000000..f39badc
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/leftRightProperties_expected.css
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* A basic test for switching the left and right properties */
+.selector {
+  right: 1px;
+}
+
+.selector2 {
+  left: 3px;
+}
+
+.selector3 {
+  padding-left: 5px;
+  margin-right: 10px;
+}
+
+.selector4 {
+  border-left-color: 1px solid blue;
+  border-right-color: red;
+}
+
+.selector5 {
+  float: right;
+  clear: right;
+}
+
+.selector6 {
+  float: left;
+  clear: left;
+}
+
+.selector7 {
+  text-align: right;
+}
+
+.selector8 {
+  page-break-after: right;
+}
+
+.selector9 {
+  page-break-before: right;
+}
+
+/* This is CSS3 syntax */
+.selector10 {
+  background: right 5px top 10px;
+}
diff --git a/user/test/com/google/gwt/resources/rg/leftRightProperties_test.css b/user/test/com/google/gwt/resources/rg/leftRightProperties_test.css
new file mode 100644
index 0000000..fc343af
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/leftRightProperties_test.css
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* A basic test for switching the left and right properties */
+.selector {
+  left: 1px;
+}
+
+.selector2 {
+  right: 3px;
+}
+
+.selector3 {
+  padding-right: 5px;
+  margin-left: 10px;
+}
+
+.selector4 {
+  border-right-color: 1px solid blue;
+  border-left-color: red;
+}
+
+.selector5 {
+  float: left;
+  clear: left;
+}
+
+.selector6 {
+  float: right;
+  clear: right;
+}
+
+.selector7 {
+  text-align: left;
+}
+
+.selector8 {
+  page-break-after: left;
+}
+
+.selector9 {
+  page-break-before: left;
+}
+
+/* This is CSS3 syntax */
+.selector10 {
+  background: left 5px top 10px;
+}
diff --git a/user/test/com/google/gwt/resources/rg/noflip_expected.css b/user/test/com/google/gwt/resources/rg/noflip_expected.css
new file mode 100644
index 0000000..8f2fcd4
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/noflip_expected.css
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+.selector1 {
+  right: 1px;
+}
+
+/* The following should not be affected. */
+
+@noflip {
+  .selector2 {
+    left: 1px;
+  }
+}
diff --git a/user/test/com/google/gwt/resources/rg/noflip_test.css b/user/test/com/google/gwt/resources/rg/noflip_test.css
new file mode 100644
index 0000000..059cf85
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/noflip_test.css
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+.selector1 {
+  left: 1px;
+}
+
+/* The following should not be affected. */
+
+@noflip {
+  .selector2 {
+    left: 1px;
+  }
+}
diff --git a/user/test/com/google/gwt/resources/rg/propertyMerging_expected.css b/user/test/com/google/gwt/resources/rg/propertyMerging_expected.css
new file mode 100644
index 0000000..e94e068
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/propertyMerging_expected.css
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* Tests merging selectors with identical properties */
+.a , .b {
+  group: one;
+}
+.c {
+  group: two;
+  border: green;
+}
+
+.d{
+  border: green;
+  group: two;
+}
+
+.e , .e2 , .g {
+  group: five;
+}
+
+.f {
+  unrelated: six;
+}
+
+.noMergeExact1 {
+  group: three;
+  border: blue;
+}
+
+.noMergeExactBlocker {
+  group: three;
+  border: thin;
+}
+
+.noMergeExact2 {
+  group: three;
+  border: blue;
+}
+
+.noMergePrefix1 {
+  group: four;
+  border: blue;
+}
+
+.noMergePrefixBlocker {
+  group: four;
+  border-top: thin;
+}
+
+.noMergePrefix2 {
+  group: four;
+  border: blue;
+}
+
+
+/* Should not merge across @if or @media blocks */
+.if {
+  group: if;
+}
+
+.ifOk, .ifOk2 {
+  group2: ifOk;
+}
+
+@if (ignored) {
+  .if2 {
+    group: if;
+  }
+}
+
+.if3 {
+  group: if;
+}
+
+.media {
+  group: media;
+}
+
+.mediaOk , .mediaOk2 {
+  group2: mediaOk;
+}
+
+@media print {
+  .media2 {
+    group: media;
+  }
+}
+
+.media3 {
+  group: media;
+}
diff --git a/user/test/com/google/gwt/resources/rg/propertyMerging_test.css b/user/test/com/google/gwt/resources/rg/propertyMerging_test.css
new file mode 100644
index 0000000..0589ccf
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/propertyMerging_test.css
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+/* Tests merging selectors with identical properties */
+.a {
+  group: one;
+}
+
+.b {
+  group: one;
+}
+
+.c {
+  group: two;
+  border: green;
+}
+
+.d{
+  border: green;
+  group: two;
+}
+
+.e , .e2 {
+  group: five;
+}
+
+.f {
+  unrelated: six;
+}
+
+.g {
+  group: five;
+}
+
+.noMergeExact1 {
+  group: three;
+  border: blue;
+}
+
+.noMergeExactBlocker {
+  group: three;
+  border: thin;
+}
+
+.noMergeExact2 {
+  group: three;
+  border: blue;
+}
+
+.noMergePrefix1 {
+  group: four;
+  border: blue;
+}
+
+.noMergePrefixBlocker {
+  group: four;
+  border-top: thin;
+}
+
+.noMergePrefix2 {
+  group: four;
+  border: blue;
+}
+
+/* Should not merge across @if or @media blocks */
+.if {
+  group: if;
+}
+
+.ifOk {
+  group2: ifOk;
+}
+
+@if (ignored) {
+  .if2 {
+    group: if;
+  }
+}
+
+.ifOk2 {
+  group2: ifOk;
+}
+
+.if3 {
+  group: if;
+}
+
+.media {
+  group: media;
+}
+
+.mediaOk {
+  group2: mediaOk;
+}
+
+@media print {
+  .media2 {
+    group: media;
+  }
+}
+
+.mediaOk2 {
+  group2: mediaOk;
+}
+
+
+.media3 {
+  group: media;
+}
diff --git a/user/test/com/google/gwt/resources/rg/selectorMerging_expected.css b/user/test/com/google/gwt/resources/rg/selectorMerging_expected.css
new file mode 100644
index 0000000..c48b61f
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/selectorMerging_expected.css
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+ /* Tests merging adjacent rules with identical selectors */
+a {
+  prop: value; foo: bar;
+}
+
+c {
+  prop: value;
+}
+
+aNonBlocker {
+  random: other;
+}
+
+b {
+  border-left: 1px;
+}
+
+bBlocker {
+  border: solid;
+}
+
+b {
+  border-right: 2px;
+}
+
+/* Test blocking across @if rules. */
+if {
+  if1 : true;
+  if5 : true;
+}
+
+@if (true) {
+  if {
+    if3 : true;
+  }
+}
+
+if {
+  if3-block: false;
+}
+
+/* Test blocking across @media rules. */
+media {
+  media1 : true;
+  media5 : true;
+}
+
+@if (true) {
+  media {
+    media3 : true;
+  }
+}
+
+media {
+  media3-block : false;
+}
diff --git a/user/test/com/google/gwt/resources/rg/selectorMerging_test.css b/user/test/com/google/gwt/resources/rg/selectorMerging_test.css
new file mode 100644
index 0000000..fd5225c
--- /dev/null
+++ b/user/test/com/google/gwt/resources/rg/selectorMerging_test.css
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+ 
+ /* Tests merging adjacent rules with identical selectors */
+a , c {
+  prop: value;
+}
+
+aNonBlocker {
+  random: other;
+}
+
+a {
+  foo: bar;
+}
+
+b {
+  border-left: 1px;
+}
+
+bBlocker {
+  border: solid;
+}
+
+b {
+  border-right: 2px;
+}
+
+/* Test blocking across @if rules. */
+if {
+  if1 : true;
+}
+
+@if (true) {
+  if {
+    if3 : true;
+  }
+}
+
+if {
+  if5 : true;
+}
+
+if {
+  if3-block : false;
+}
+
+/* Test blocking across @media rules. */
+media {
+  media1 : true;
+}
+
+@if (true) {
+  media {
+    media3 : true;
+  }
+}
+
+media {
+  media5 : true;
+}
+
+media {
+  media3-block : false;
+}