diff --git a/dev/core/src/com/google/gwt/core/ext/CachedGeneratorResult.java b/dev/core/src/com/google/gwt/core/ext/CachedGeneratorResult.java
new file mode 100644
index 0000000..f2934c1
--- /dev/null
+++ b/dev/core/src/com/google/gwt/core/ext/CachedGeneratorResult.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2011 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.core.ext;
+
+/**
+ * An interface to represent the cached results from a previous generator
+ * invocation. This is made available in the {@link GeneratorContext} to
+ * subsequent invocations of the same generator, when called under the same
+ * conditions (e.g. for the same rebind rule and requested type name).
+ * 
+ * @see GeneratorContext#getCachedGeneratorResult
+ */
+public interface CachedGeneratorResult {
+  /**
+   * Retrieves cached client data by key.
+   */
+  Object getClientData(String key);
+
+  /**
+   * Returns the cached result rebind type name.
+   */
+  String getResultTypeName();
+
+  /**
+   * Returns the time this generator result was created.
+   */
+  long getTimeGenerated();
+
+  /**
+   * Check whether a given type is present in the cached result.
+   */
+  boolean isTypeCached(String typeName);
+}
\ No newline at end of file
diff --git a/dev/core/src/com/google/gwt/dev/javac/rebind/CachedPropertyInformation.java b/dev/core/src/com/google/gwt/core/ext/CachedPropertyInformation.java
similarity index 91%
rename from dev/core/src/com/google/gwt/dev/javac/rebind/CachedPropertyInformation.java
rename to dev/core/src/com/google/gwt/core/ext/CachedPropertyInformation.java
index bddb4a7..85d7659 100644
--- a/dev/core/src/com/google/gwt/dev/javac/rebind/CachedPropertyInformation.java
+++ b/dev/core/src/com/google/gwt/core/ext/CachedPropertyInformation.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010 Google Inc.
+ * Copyright 2011 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
@@ -13,13 +13,7 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.google.gwt.dev.javac.rebind;
-
-import com.google.gwt.core.ext.BadPropertyValueException;
-import com.google.gwt.core.ext.ConfigurationProperty;
-import com.google.gwt.core.ext.PropertyOracle;
-import com.google.gwt.core.ext.SelectionProperty;
-import com.google.gwt.core.ext.TreeLogger;
+package com.google.gwt.core.ext;
 
 import java.io.Serializable;
 import java.util.ArrayList;
diff --git a/dev/core/src/com/google/gwt/core/ext/GeneratorContextExtWrapper.java b/dev/core/src/com/google/gwt/core/ext/DelegatingGeneratorContext.java
similarity index 69%
rename from dev/core/src/com/google/gwt/core/ext/GeneratorContextExtWrapper.java
rename to dev/core/src/com/google/gwt/core/ext/DelegatingGeneratorContext.java
index b429da3..fe68961 100644
--- a/dev/core/src/com/google/gwt/core/ext/GeneratorContextExtWrapper.java
+++ b/dev/core/src/com/google/gwt/core/ext/DelegatingGeneratorContext.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010 Google Inc.
+ * Copyright 2011 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
@@ -18,90 +18,92 @@
 import com.google.gwt.core.ext.linker.Artifact;
 import com.google.gwt.core.ext.linker.GeneratedResource;
 import com.google.gwt.core.ext.typeinfo.TypeOracle;
-import com.google.gwt.dev.javac.rebind.CachedRebindResult;
 import com.google.gwt.dev.resource.ResourceOracle;
 
 import java.io.OutputStream;
 import java.io.PrintWriter;
 
 /**
- * EXPERIMENTAL and subject to change. Do not use this in production code.
- * <p>
- * A wrapper to access a base {@link GeneratorContext} instance as a
- * {@link GeneratorContextExt} instance. Methods from the
- * {@link GeneratorContext} interface are passed through to the baseContext,
- * while methods from the {@link GeneratorContextExt} interface are given
- * default stub implementations.
+ * An abstract generator context class which delegates all methods to a provided
+ * baseContext. Implementing classes can selectively override individual
+ * methods.
  */
-public class GeneratorContextExtWrapper implements GeneratorContextExt {
+public abstract class DelegatingGeneratorContext implements GeneratorContext {
+
+  private final GeneratorContext baseContext;
 
   /**
    * Get a new instance wrapped from a base {@link GeneratorContext}
    * implementation.
    */
-  public static GeneratorContextExt newInstance(GeneratorContext baseContext) {
-    return new GeneratorContextExtWrapper(baseContext);
-  }
-
-  private final GeneratorContext baseContext;
-
-  private GeneratorContextExtWrapper(GeneratorContext baseContext) {
+  public DelegatingGeneratorContext(GeneratorContext baseContext) {
     this.baseContext = baseContext;
   }
 
+  @Override
   public boolean checkRebindRuleAvailable(String sourceTypeName) {
     return baseContext.checkRebindRuleAvailable(sourceTypeName);
   }
 
+  @Override
   public void commit(TreeLogger logger, PrintWriter pw) {
     baseContext.commit(logger, pw);
   }
 
+  @Override
   public void commitArtifact(TreeLogger logger, Artifact<?> artifact)
       throws UnableToCompleteException {
     baseContext.commitArtifact(logger, artifact);
   }
 
+  @Override
   public GeneratedResource commitResource(TreeLogger logger, OutputStream os)
       throws UnableToCompleteException {
     return baseContext.commitResource(logger, os);
   }
 
-  public CachedRebindResult getCachedGeneratorResult() {
-    return null;
+  @Override
+  public CachedGeneratorResult getCachedGeneratorResult() {
+    return baseContext.getCachedGeneratorResult();
   }
 
+  @Override
   public PropertyOracle getPropertyOracle() {
     return baseContext.getPropertyOracle();
   }
 
+  @Override
   public ResourceOracle getResourcesOracle() {
     return baseContext.getResourcesOracle();
   }
 
+  @Override
   public TypeOracle getTypeOracle() {
     return baseContext.getTypeOracle();
   }
 
+  @Override
   public boolean isGeneratorResultCachingEnabled() {
-    return false;
+    return baseContext.isGeneratorResultCachingEnabled();
   }
 
+  @Override
   public boolean isProdMode() {
-    throw new UnsupportedOperationException(
-        "isProdMode is only available from GeneratorContextExt.");
+    return baseContext.isProdMode();
   }
-
-  public boolean reuseTypeFromCacheIfAvailable(String typeName) {
-    return false;
-  }
-
+  @Override
   public PrintWriter tryCreate(TreeLogger logger, String packageName, String simpleName) {
     return baseContext.tryCreate(logger, packageName, simpleName);
   }
 
+  @Override
   public OutputStream tryCreateResource(TreeLogger logger, String partialPath)
       throws UnableToCompleteException {
     return baseContext.tryCreateResource(logger, partialPath);
   }
+
+  @Override
+  public boolean tryReuseTypeFromCache(String typeName) {
+    return baseContext.tryReuseTypeFromCache(typeName);
+  }
 }
diff --git a/dev/core/src/com/google/gwt/core/ext/GeneratorContext.java b/dev/core/src/com/google/gwt/core/ext/GeneratorContext.java
index 6e70447..fb1b905 100644
--- a/dev/core/src/com/google/gwt/core/ext/GeneratorContext.java
+++ b/dev/core/src/com/google/gwt/core/ext/GeneratorContext.java
@@ -53,9 +53,8 @@
    * {@link com.google.gwt.core.ext.linker.ArtifactSet#replace(Artifact)} if an
    * equivalent Artifact had previously been committed.
    * 
-   * @param logger a logger; normally the logger passed into
-   *          {@link Generator#generate(TreeLogger, GeneratorContext, String)}
-   *          or a branch thereof
+   * @param logger a logger; normally the logger passed into the currently
+   *          invoked generator or a branch thereof
    * @param artifact the Artifact to provide to the Linker chain.
    */
   void commitArtifact(TreeLogger logger, Artifact<?> artifact) throws UnableToCompleteException;
@@ -74,6 +73,17 @@
       throws UnableToCompleteException;
 
   /**
+   * Get the cached rebind result that has been provided to the context, if
+   * available. The provided result will be the most recent previously generated
+   * result for the currently active rebind rule and requested type name.
+   * 
+   * @return A {@link CachedGeneratorResult} object, if one has been provided to
+   *         the context. Null is returned if there is no previous result
+   *         available.
+   */
+  CachedGeneratorResult getCachedGeneratorResult();
+
+  /**
    * Gets the property oracle for the current generator context. Generators can
    * use the property oracle to query deferred binding properties.
    */
@@ -100,15 +110,26 @@
   TypeOracle getTypeOracle();
 
   /**
+   * Check whether generator result caching is currently enabled.
+   */
+  boolean isGeneratorResultCachingEnabled();
+
+  /**
+   * Returns true if generators are being run to produce code for a production
+   * compile. Returns false for dev mode. Generators can use this information to
+   * produce code optimized for the target.
+   */
+  boolean isProdMode();
+
+  /**
    * Attempts to get a <code>PrintWriter</code> so that the caller can generate
    * the source code for the named type. If the named types already exists,
    * <code>null</code> is returned to indicate that no work needs to be done.
    * The file is not committed until {@link #commit(TreeLogger, PrintWriter)} is
    * called.
    * 
-   * @param logger a logger; normally the logger passed into
-   *          {@link Generator#generate(TreeLogger, GeneratorContext, String)}
-   *          or a branch thereof
+   * @param logger a logger; normally the logger passed into the currently
+   *          invoked generator, or a branch thereof
    * @param packageName the name of the package to which the create type belongs
    * @param simpleName the unqualified source name of the type being generated
    * @return <code>null</code> if the package and class already exists,
@@ -122,9 +143,8 @@
    * directory. The file is not committed until
    * {@link #commitResource(TreeLogger, OutputStream)} is called.
    * 
-   * @param logger a logger; normally the logger passed into
-   *          {@link Generator#generate(TreeLogger, GeneratorContext, String)}
-   *          or a branch thereof
+   * @param logger a logger; normally the logger passed into the currently
+   *          invoked generator, or a branch thereof
    * @param partialPath the name of the file whose contents are to be written;
    *          the name can include subdirectories separated by forward slashes
    *          ('/')
@@ -136,4 +156,18 @@
    */
   OutputStream tryCreateResource(TreeLogger logger, String partialPath)
       throws UnableToCompleteException;
+
+  /**
+   * Mark a type to be reused from the generator result cache, if available.
+   * Calling this method with a successful response indicates that the calling
+   * generator will not re-generate this type. A cached version of this type
+   * will be added to the context once the calling generator returns from
+   * {@link IncrementalGenerator#generateIncrementally}, with a result
+   * containing {@link RebindMode#USE_PARTIAL_CACHED}.
+   * 
+   * @param typeName the fully qualified source name of a type.
+   * @return true if the requested type is available from the generator result
+   *         cache, false otherwise.
+   */
+  boolean tryReuseTypeFromCache(String typeName);
 }
diff --git a/dev/core/src/com/google/gwt/core/ext/GeneratorContextExt.java b/dev/core/src/com/google/gwt/core/ext/GeneratorContextExt.java
deleted file mode 100644
index 7153684..0000000
--- a/dev/core/src/com/google/gwt/core/ext/GeneratorContextExt.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright 2010 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.core.ext;
-
-import com.google.gwt.dev.javac.rebind.CachedRebindResult;
-
-/**
- * EXPERIMENTAL and subject to change. Do not use this in production code.
- * <p>
- * An extension to GeneratorContext which includes access to previously cached
- * rebind results.
- * <p> 
- * TODO(jbrosenberg): Merge this into {@link GeneratorContext} directly, once 
- * the api has stabilized and we can remove the "experimental" moniker.
- */
-public interface GeneratorContextExt extends GeneratorContext {
-  
-  /**
-   * Get cached result from a previous run of the current generator, if available.
-   * 
-   * @return A {@link com.google.gwt.dev.javac.rebind.CachedRebindResult} object,
-   *         if one has been provided to the context.  Null is returned if there
-   *         is no previous result, or if generator result caching is not enabled.
-   */
-  CachedRebindResult getCachedGeneratorResult();
-  
-  /**
-   * Check whether generator result caching is currently enabled.
-   */
-  boolean isGeneratorResultCachingEnabled();
-
-  /**
-   * Returns true if generators are being run to produce code for a
-   * production compile. Returns false for dev mode. Generators can use this
-   * information to produce code optimized for the target. 
-   */
-  boolean isProdMode();
-  
-  /**
-   * Mark a type to be reused from the generator result cache.  Calling this
-   * method with a successful response indicates that the calling generator will 
-   * not re-generate this type.  A cached version of this type will be added
-   * to the context once the calling generator returns from 
-   * {@link GeneratorExt#generateIncrementally}, with a result containing 
-   * {@link com.google.gwt.dev.javac.rebind.RebindStatus#USE_PARTIAL_CACHED}.
-   * 
-   * @param typeName the fully qualified name of a type.
-   * @return true if the requested type is available from the generator result 
-   *         cache, false otherwise.
-   */
-  boolean reuseTypeFromCacheIfAvailable(String typeName);
-}
diff --git a/dev/core/src/com/google/gwt/core/ext/GeneratorExt.java b/dev/core/src/com/google/gwt/core/ext/GeneratorExt.java
deleted file mode 100644
index 4e24aaf..0000000
--- a/dev/core/src/com/google/gwt/core/ext/GeneratorExt.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright 2010 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.core.ext;
-
-import com.google.gwt.dev.javac.rebind.RebindResult;
-
-/**
- * EXPERIMENTAL and subject to change. Do not use this in production code.
- * <p>
- * Adds a new {@link #generateIncrementally} method.
- * <p> 
- * TODO(jbrosenberg): Merge this into {@link Generator} directly, once the api
- * has stabilized and we can remove the "experimental" moniker.
- */
-public abstract class GeneratorExt extends Generator {
- 
-  /**
-   * A default implementation of the abstract method defined in the base
-   * {@link Generator} class.  This will wrap a call to
-   * {@link #generateIncrementally}, and attempt no caching.  This supports
-   * backwards compatibility for applications or other generators which call 
-   * this generator directly, as outside of the normal internal rebind process.
-   * <p>
-   * It is recommended that {@link #generateIncrementally} be used instead.
-   * 
-   * @return the name of a subclass to substitute for the requested class, or
-   *         return <code>null</code> to cause the requested type itself to be
-   *         used
-   */
-  @Override
-  public String generate(TreeLogger logger, GeneratorContext context,
-      String typeName) throws UnableToCompleteException {
-    
-    // wrap the passed in context
-    GeneratorContextExt contextExt = context instanceof GeneratorContextExt
-        ? (GeneratorContextExt) context
-        : GeneratorContextExtWrapper.newInstance(context);
-    
-    RebindResult result = generateIncrementally(logger, contextExt, typeName);
-    return result.getReturnedTypeName();
-  }
-  
-  /**
-   * Incrementally generate a default constructible subclass of the requested 
-   * type.  The generator can use information from the context to determine
-   * whether it needs to regenerate everything, or whether it can selectively
-   * regenerate a subset of its output, or whether it can return quickly to
-   * allow reuse of all previously cached objects.  It will return a 
-   * {@link RebindResult}, which contains a
-   * {@link com.google.gwt.dev.javac.rebind.RebindStatus} field indicating
-   * whether to use previously cached artifacts, newly generated ones, or a
-   * partial mixture of both cached and newly generated objects.
-   * <p>
-   * The result also includes a field for the name of the subclass to 
-   * substitute for the requested class.
-   * <p>
-   * The generator throws an <code>UnableToCompleteException</code> if for 
-   * any reason it cannot complete successfully.
-   * 
-   * @return a RebindResult
-   */
-  public abstract RebindResult generateIncrementally(TreeLogger logger, 
-      GeneratorContextExt context, String typeName) 
-      throws UnableToCompleteException;
-}
diff --git a/dev/core/src/com/google/gwt/core/ext/GeneratorExtWrapper.java b/dev/core/src/com/google/gwt/core/ext/GeneratorExtWrapper.java
deleted file mode 100644
index bc8a250..0000000
--- a/dev/core/src/com/google/gwt/core/ext/GeneratorExtWrapper.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright 2010 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.core.ext;
-
-import com.google.gwt.dev.javac.rebind.RebindResult;
-import com.google.gwt.dev.javac.rebind.RebindStatus;
-
-/**
- * EXPERIMENTAL and subject to change. Do not use this in production code.
- * <p>  
- * A wrapper class for using base {@link Generator} implementations where
- * a {@link GeneratorExt} instance is needed.
- */
-public class GeneratorExtWrapper extends GeneratorExt {
- 
-  /**
-   * Get a new instance wrapped from a base {@link Generator} implementation.
-   */
-  public static GeneratorExt newInstance(Generator baseGenerator) {
-    return new GeneratorExtWrapper(baseGenerator);
-  }
-
-  private final Generator baseGenerator;
- 
-  public GeneratorExtWrapper(Generator baseGenerator) {
-    this.baseGenerator = baseGenerator;
-  }
- 
-  /**
-   * Pass through to the base generator's generate method.
-   */
-  @Override
-  public String generate(TreeLogger logger, GeneratorContext context,
-      String typeName) throws UnableToCompleteException {
-    return this.baseGenerator.generate(logger, context, typeName);
-  }
-
-  /**
-   * Call base generator's generate method, and don't attempt any caching.
-   */
-  @Override
-  public RebindResult generateIncrementally(TreeLogger logger, 
-      GeneratorContextExt context, String typeName) 
-      throws UnableToCompleteException {
-
-    RebindStatus status;
-    String resultTypeName = generate(logger, context, typeName);
-    if (resultTypeName == null) {
-      status = RebindStatus.USE_EXISTING;
-      resultTypeName = typeName;
-    } else {
-      status = RebindStatus.USE_ALL_NEW_WITH_NO_CACHING;
-    }
-
-    return new RebindResult(status, resultTypeName);
-  }
-}
\ No newline at end of file
diff --git a/dev/core/src/com/google/gwt/core/ext/IncrementalGenerator.java b/dev/core/src/com/google/gwt/core/ext/IncrementalGenerator.java
new file mode 100644
index 0000000..e42c678
--- /dev/null
+++ b/dev/core/src/com/google/gwt/core/ext/IncrementalGenerator.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2011 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.core.ext;
+
+/**
+ * An extension to the {@link Generator} class which supports incremental
+ * generation. It adds a {@link #generateIncrementally} method.
+ */
+public abstract class IncrementalGenerator extends Generator {
+
+  /**
+   * A static helper method to wrap a non-incremental generator's result. It
+   * calls the generator's {@link Generator#generate} method, and synthesizes a
+   * {@link RebindResult} instance to be returned.
+   * 
+   * @param logger A TreeLogger
+   * @param generator A non-incremental generator
+   * @param context The generator context
+   * @param typeName The type for which a subclass will be generated
+   * @return a RebindResult
+   * @throws UnableToCompleteException
+   */
+  public static RebindResult generateNonIncrementally(TreeLogger logger, Generator generator,
+      GeneratorContext context, String typeName) throws UnableToCompleteException {
+
+    RebindMode mode;
+    String resultTypeName = generator.generate(logger, context, typeName);
+    if (resultTypeName == null) {
+      mode = RebindMode.USE_EXISTING;
+      resultTypeName = typeName;
+    } else {
+      mode = RebindMode.USE_ALL_NEW_WITH_NO_CACHING;
+    }
+
+    return new RebindResult(mode, resultTypeName);
+  }
+
+  /**
+   * This method overrides {@link Generator#generate}, and is included only for
+   * backwards compatibility. It wraps a call to {@link #generateIncrementally}.
+   * This method won't normally be called by the gwt rebind process, and it is
+   * declared final and can't be overridden. It is provided in support of
+   * existing applications and other generators which call this method directly,
+   * outside of the gwt framework.
+   * <p>
+   * The passed in context is wrapped with an instance of
+   * {@link NonIncrementalGeneratorContext}, to ensure that no generator result
+   * caching is attempted, since the cached result will be ignored by callers of
+   * this method anyway.
+   * 
+   * @see Generator#generate
+   * 
+   * @param logger A TreeLogger
+   * @param context The generator context
+   * @param typeName The type for which a subclass will be generated
+   * @return the name of a subclass to substitute for the requested class, or
+   *         return <code>null</code> to cause the requested type itself to be
+   *         used
+   * @throws UnableToCompleteException
+   */
+  @Override
+  public final String generate(TreeLogger logger, GeneratorContext context, String typeName)
+      throws UnableToCompleteException {
+    /*
+     * Since no generator result caching should happen if this method is called,
+     * we wrap the context, to ensure that the check for {@link
+     * GeneratorContext.isGeneratorResultCachingEnabled()} will return false.
+     */
+    GeneratorContext wrappedContext = NonIncrementalGeneratorContext.newInstance(context);
+    RebindResult result = generateIncrementally(logger, wrappedContext, typeName);
+    return result.getResultTypeName();
+  }
+
+  /**
+   * Incrementally generate a default constructible subclass of the requested
+   * type. The generator can use information from the context to make decisions
+   * on whether to incrementally reuse cached output from previous invocations.
+   * <p>
+   * It returns a {@link RebindResult}, which contains a {@link RebindMode}
+   * field, which indicates whether to use previously cached output, newly
+   * generated output, or a partial mixture of both cached and newly generated
+   * output.
+   * <p>
+   * The result also includes a field for the name of the subclass to substitute
+   * for the requested class. It may also contain extra client data added by
+   * specific generator implementations.
+   * <p>
+   * This method throws an <code>UnableToCompleteException</code> if for any
+   * reason it cannot complete successfully.
+   * 
+   * @see RebindResult
+   * @see RebindMode
+   * 
+   * @param logger A TreeLogger
+   * @param context The generator context
+   * @param typeName The type for which a subclass will be generated
+   * @return a RebindResult
+   * @throws UnableToCompleteException
+   */
+  public abstract RebindResult generateIncrementally(TreeLogger logger, GeneratorContext context,
+      String typeName) throws UnableToCompleteException;
+
+  /**
+   * Returns a version id for an IncrementalGenerator. It is used by the system
+   * to invalidate {@link CachedGeneratorResult}'s that were generated by a
+   * different version of this generator. This is useful when new versions of a
+   * generator are developed, which might alter the structure of generated
+   * output, or alter semantics for cache reusability checking.
+   * <p>
+   * It is the responsibility of the developer to maintain this version id
+   * consistently.
+   * 
+   * @return a version id
+   */
+  public abstract long getVersionId();
+}
diff --git a/dev/core/src/com/google/gwt/core/ext/NonIncrementalGeneratorContext.java b/dev/core/src/com/google/gwt/core/ext/NonIncrementalGeneratorContext.java
new file mode 100644
index 0000000..8e70bf5
--- /dev/null
+++ b/dev/core/src/com/google/gwt/core/ext/NonIncrementalGeneratorContext.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2011 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.core.ext;
+
+/**
+ * A wrapper to access a base {@link GeneratorContext} instance but with
+ * generator result caching disabled.
+ */
+public class NonIncrementalGeneratorContext extends DelegatingGeneratorContext {
+
+  /**
+   * Get a new instance wrapped from a base {@link GeneratorContext}
+   * implementation.
+   */
+  public static GeneratorContext newInstance(GeneratorContext baseContext) {
+    return new NonIncrementalGeneratorContext(baseContext);
+  }
+
+  private NonIncrementalGeneratorContext(GeneratorContext baseContext) {
+    super(baseContext);
+  }
+
+  @Override
+  public CachedGeneratorResult getCachedGeneratorResult() {
+    // disabled
+    return null;
+  }
+
+  @Override
+  public boolean isGeneratorResultCachingEnabled() {
+    // disabled
+    return false;
+  }
+
+  @Override
+  public boolean tryReuseTypeFromCache(String typeName) {
+    // disabled
+    return false;
+  }
+}
diff --git a/dev/core/src/com/google/gwt/core/ext/RebindMode.java b/dev/core/src/com/google/gwt/core/ext/RebindMode.java
new file mode 100644
index 0000000..4362d65
--- /dev/null
+++ b/dev/core/src/com/google/gwt/core/ext/RebindMode.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2011 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.core.ext;
+
+/**
+ * A mode to indicate how incremental generator output should be integrated by
+ * the deferred binding implementation. The RebindMode is included as a member
+ * of the {@link RebindResult} returned by
+ * {@link IncrementalGenerator#generateIncrementally}. It is up to each
+ * generator implementation to determine the conditions for reuse of previously
+ * generated cached output.
+ * 
+ * @see RebindResult
+ * @see IncrementalGenerator#generateIncrementally
+ */
+public enum RebindMode {
+
+  /**
+   * Indicates no generated code is needed to satisfy this rebind. This mode can
+   * be used in cases where the requested type can be used directly as a default
+   * instantiable class, or in cases where a generator determines it has already
+   * run for the requested type in the current context (e.g. via a failed call
+   * to {@link GeneratorContext#tryCreate}).
+   */
+  USE_EXISTING,
+
+  /**
+   * Indicates only newly generated output should be used. All generated output
+   * will be cached.
+   */
+  USE_ALL_NEW,
+
+  /**
+   * Indicates only newly generated output should be used, and no output should
+   * be cached. This mode should be used when no caching can be taken advantage
+   * of, such as for generators which don't implement
+   * {@link IncrementalGenerator#generateIncrementally}.
+   */
+  USE_ALL_NEW_WITH_NO_CACHING,
+
+  /**
+   * Indicates nothing new was generated, only cached output previously
+   * generated should be used.
+   */
+  USE_ALL_CACHED,
+
+  /**
+   * Indicates that a mixture of newly generated and previously cached output
+   * should be used. Types marked with a successful call to
+   * {@link GeneratorContext#tryReuseTypeFromCache} should be reused from cache,
+   * while everything else committed to the context should be treated as freshly
+   * generated output. A new composite cache entry will be created which
+   * combines the freshly generated output and the output reused from cache.
+   */
+  USE_PARTIAL_CACHED
+}
diff --git a/dev/core/src/com/google/gwt/core/ext/RebindResult.java b/dev/core/src/com/google/gwt/core/ext/RebindResult.java
new file mode 100644
index 0000000..f310ee6
--- /dev/null
+++ b/dev/core/src/com/google/gwt/core/ext/RebindResult.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2011 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.core.ext;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A class for returning the result of a rebind operation.
+ */
+public class RebindResult {
+  private final RebindMode rebindMode;
+  private final String resultTypeName;
+  private Map<String, Serializable> clientData;
+
+  /**
+   * Constructs a result using the provided rebindMode and resultTypeName.
+   * 
+   * @see RebindMode
+   * 
+   * @param rebindMode
+   * @param resultType
+   */
+  public RebindResult(RebindMode rebindMode, String resultType) {
+    this.rebindMode = rebindMode;
+    this.resultTypeName = resultType;
+  }
+
+  /**
+   * Returns a map containing all client data added to this result.
+   * 
+   * @return A map containing all client data added to this result. Returns
+   *         <code>null</code> if no client data has been added.
+   */
+  public Map<String, Serializable> getClientDataMap() {
+    return clientData;
+  }
+
+  /**
+   * @return The rebind mode used to construct this result.
+   */
+  public RebindMode getRebindMode() {
+    return rebindMode;
+  }
+
+  /**
+   * @return The type name used to construct this result.
+   */
+  public String getResultTypeName() {
+    return resultTypeName;
+  }
+
+  /**
+   * Adds keyed, serializable data to a rebind result. This data will be made
+   * available, as part of a {@link CachedGeneratorResult}, to subsequent
+   * invocations of the same generator, when called under the same conditions
+   * (e.g. for the same rebind rule and requested type name). A generator
+   * implementation can use this to remember information needed for subsequent
+   * regeneration, such as for making cache reuse decisions.
+   * 
+   * @see CachedGeneratorResult
+   * @see GeneratorContext#getCachedGeneratorResult
+   * 
+   * @param key
+   * @param data
+   */
+  public void putClientData(String key, Serializable data) {
+    if (clientData == null) {
+      clientData = new HashMap<String, Serializable>();
+    }
+    clientData.put(key, data);
+  } 
+}
\ No newline at end of file
diff --git a/dev/core/src/com/google/gwt/dev/javac/rebind/RebindRuleResolver.java b/dev/core/src/com/google/gwt/core/ext/RebindRuleResolver.java
similarity index 94%
rename from dev/core/src/com/google/gwt/dev/javac/rebind/RebindRuleResolver.java
rename to dev/core/src/com/google/gwt/core/ext/RebindRuleResolver.java
index 5cc5dcb..7dcc7cf 100644
--- a/dev/core/src/com/google/gwt/dev/javac/rebind/RebindRuleResolver.java
+++ b/dev/core/src/com/google/gwt/core/ext/RebindRuleResolver.java
@@ -13,7 +13,7 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.google.gwt.dev.javac.rebind;
+package com.google.gwt.core.ext;
 
 /**
  * An interface for encapsulating rebind rule resolution.
diff --git a/dev/core/src/com/google/gwt/core/ext/StubGeneratorContext.java b/dev/core/src/com/google/gwt/core/ext/StubGeneratorContext.java
new file mode 100644
index 0000000..b3046da
--- /dev/null
+++ b/dev/core/src/com/google/gwt/core/ext/StubGeneratorContext.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2011 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.core.ext;
+
+import com.google.gwt.core.ext.linker.Artifact;
+import com.google.gwt.core.ext.linker.GeneratedResource;
+import com.google.gwt.core.ext.typeinfo.TypeOracle;
+import com.google.gwt.dev.resource.ResourceOracle;
+
+import java.io.OutputStream;
+import java.io.PrintWriter;
+
+/**
+ * An abstract generator context class which by default throws
+ * UnsupportedOperationException for all methods. Implementing classes can
+ * selectively override individual methods. Useful for mocking and/or selective
+ * reuse of generator functionality.
+ */
+public abstract class StubGeneratorContext implements GeneratorContext {
+
+  @Override
+  public boolean checkRebindRuleAvailable(String sourceTypeName) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public void commit(TreeLogger logger, PrintWriter pw) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public void commitArtifact(TreeLogger logger, Artifact<?> artifact) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public GeneratedResource commitResource(TreeLogger logger, OutputStream os) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public CachedGeneratorResult getCachedGeneratorResult() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public PropertyOracle getPropertyOracle() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public ResourceOracle getResourcesOracle() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public TypeOracle getTypeOracle() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean isGeneratorResultCachingEnabled() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean isProdMode() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public PrintWriter tryCreate(TreeLogger logger, String packageName, String simpleName) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public OutputStream tryCreateResource(TreeLogger logger, String partialPath) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean tryReuseTypeFromCache(String typeName) {
+    throw new UnsupportedOperationException();
+  }
+}
\ No newline at end of file
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java
index fdee5dc..d6cfd1f 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java
@@ -19,10 +19,7 @@
  * Type representing a Java class or interface type that a user would declare.
  */
 public interface JRealClassType extends JClassType {
-  
   /**
-   * EXPERIMENTAL and subject to change. Do not use this in production code.
-   * 
    * Retrieve last modified time for this type.
    */
   long getLastModifiedTime();
diff --git a/dev/core/src/com/google/gwt/dev/DevModeBase.java b/dev/core/src/com/google/gwt/dev/DevModeBase.java
index 69d575b..d4374c8 100644
--- a/dev/core/src/com/google/gwt/dev/DevModeBase.java
+++ b/dev/core/src/com/google/gwt/dev/DevModeBase.java
@@ -23,7 +23,6 @@
 import com.google.gwt.dev.cfg.ModuleDefLoader;
 import com.google.gwt.dev.javac.CompilationState;
 import com.google.gwt.dev.javac.CompilationStateBuilder;
-import com.google.gwt.dev.javac.rebind.RebindCache;
 import com.google.gwt.dev.jjs.JJSOptions;
 import com.google.gwt.dev.shell.ArtifactAcceptor;
 import com.google.gwt.dev.shell.BrowserChannelServer;
diff --git a/dev/core/src/com/google/gwt/dev/javac/rebind/RebindCache.java b/dev/core/src/com/google/gwt/dev/RebindCache.java
similarity index 62%
rename from dev/core/src/com/google/gwt/dev/javac/rebind/RebindCache.java
rename to dev/core/src/com/google/gwt/dev/RebindCache.java
index b1e7caa..cff8ea1 100644
--- a/dev/core/src/com/google/gwt/dev/javac/rebind/RebindCache.java
+++ b/dev/core/src/com/google/gwt/dev/RebindCache.java
@@ -13,8 +13,9 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.google.gwt.dev.javac.rebind;
+package com.google.gwt.dev;
 
+import com.google.gwt.core.ext.CachedGeneratorResult;
 import com.google.gwt.dev.cfg.Rule;
 
 import java.io.Serializable;
@@ -22,19 +23,19 @@
 import java.util.Map;
 
 /**
- * A cache for storing {@link CachedRebindResult} entries.  Entries are keyed
+ * A cache for storing {@link CachedGeneratorResult} entries.  Entries are keyed
  * by rebind Rule and queryTypeName.
  */
 public class RebindCache implements Serializable {
  
-  private final Map<String, Map<String, CachedRebindResult>> rebindResults;
+  private final Map<String, Map<String, CachedGeneratorResult>> rebindResults;
   
   public RebindCache() {
-    rebindResults = new HashMap<String, Map<String, CachedRebindResult>>();
+    rebindResults = new HashMap<String, Map<String, CachedGeneratorResult>>();
   }
 
-  public CachedRebindResult get(Rule rule, String queryTypeName) {
-    Map<String, CachedRebindResult> ruleResults;
+  public CachedGeneratorResult get(Rule rule, String queryTypeName) {
+    Map<String, CachedGeneratorResult> ruleResults;
     ruleResults = rebindResults.get(rule.toString());
     if (ruleResults != null) {
       return ruleResults.get(queryTypeName);
@@ -42,15 +43,11 @@
 
     return null;
   }
-  
-  public void invalidate() {
-    rebindResults.clear();
-  }
-  
-  public void put(Rule rule, String queryTypeName, CachedRebindResult results) {
-    Map<String, CachedRebindResult> ruleResults = rebindResults.get(rule.toString());
+
+  public void put(Rule rule, String queryTypeName, CachedGeneratorResult results) {
+    Map<String, CachedGeneratorResult> ruleResults = rebindResults.get(rule.toString());
     if (ruleResults == null) {
-      ruleResults = new HashMap<String, CachedRebindResult>();
+      ruleResults = new HashMap<String, CachedGeneratorResult>();
       rebindResults.put(rule.toString(), ruleResults);
     }
     ruleResults.put(queryTypeName, results);
diff --git a/dev/core/src/com/google/gwt/dev/cfg/Rule.java b/dev/core/src/com/google/gwt/dev/cfg/Rule.java
index 818bf3e..6b8a889 100644
--- a/dev/core/src/com/google/gwt/dev/cfg/Rule.java
+++ b/dev/core/src/com/google/gwt/dev/cfg/Rule.java
@@ -15,10 +15,10 @@
  */
 package com.google.gwt.dev.cfg;
 
+import com.google.gwt.core.ext.RebindResult;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.javac.StandardGeneratorContext;
-import com.google.gwt.dev.javac.rebind.RebindResult;
 
 /**
  * Abstract base class for various kinds of deferred binding rules.
diff --git a/dev/core/src/com/google/gwt/dev/cfg/RuleFail.java b/dev/core/src/com/google/gwt/dev/cfg/RuleFail.java
index 89c0fd0..d1ef03b 100644
--- a/dev/core/src/com/google/gwt/dev/cfg/RuleFail.java
+++ b/dev/core/src/com/google/gwt/dev/cfg/RuleFail.java
@@ -15,10 +15,10 @@
  */
 package com.google.gwt.dev.cfg;
 
+import com.google.gwt.core.ext.RebindResult;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.javac.StandardGeneratorContext;
-import com.google.gwt.dev.javac.rebind.RebindResult;
 
 /**
  * A rule to explicitly fail during a deferred binding request.
diff --git a/dev/core/src/com/google/gwt/dev/cfg/RuleGenerateWith.java b/dev/core/src/com/google/gwt/dev/cfg/RuleGenerateWith.java
index e41b51d..20e3482 100644
--- a/dev/core/src/com/google/gwt/dev/cfg/RuleGenerateWith.java
+++ b/dev/core/src/com/google/gwt/dev/cfg/RuleGenerateWith.java
@@ -16,10 +16,10 @@
 package com.google.gwt.dev.cfg;
 
 import com.google.gwt.core.ext.Generator;
+import com.google.gwt.core.ext.RebindResult;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.javac.StandardGeneratorContext;
-import com.google.gwt.dev.javac.rebind.RebindResult;
 
 /**
  * A rule to replace the type being rebound with a class whose name is
diff --git a/dev/core/src/com/google/gwt/dev/cfg/RuleReplaceWith.java b/dev/core/src/com/google/gwt/dev/cfg/RuleReplaceWith.java
index 4f4f273..e2fb681 100644
--- a/dev/core/src/com/google/gwt/dev/cfg/RuleReplaceWith.java
+++ b/dev/core/src/com/google/gwt/dev/cfg/RuleReplaceWith.java
@@ -15,11 +15,11 @@
  */
 package com.google.gwt.dev.cfg;
 
+import com.google.gwt.core.ext.RebindMode;
+import com.google.gwt.core.ext.RebindResult;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.javac.StandardGeneratorContext;
-import com.google.gwt.dev.javac.rebind.RebindResult;
-import com.google.gwt.dev.javac.rebind.RebindStatus;
 
 /**
  * A rule to replace the type being rebound with an explicitly named class.
@@ -41,7 +41,7 @@
       StandardGeneratorContext context, String typeName)
       throws UnableToCompleteException {
     return new RebindResult(
-        RebindStatus.USE_EXISTING, replacementTypeName);
+        RebindMode.USE_EXISTING, replacementTypeName);
   }
 
   @Override
diff --git a/dev/core/src/com/google/gwt/dev/javac/rebind/CachedRebindResult.java b/dev/core/src/com/google/gwt/dev/javac/CachedGeneratorResultImpl.java
similarity index 64%
rename from dev/core/src/com/google/gwt/dev/javac/rebind/CachedRebindResult.java
rename to dev/core/src/com/google/gwt/dev/javac/CachedGeneratorResultImpl.java
index dc74223..986f2c0 100644
--- a/dev/core/src/com/google/gwt/dev/javac/rebind/CachedRebindResult.java
+++ b/dev/core/src/com/google/gwt/dev/javac/CachedGeneratorResultImpl.java
@@ -1,22 +1,22 @@
 /*
- * Copyright 2010 Google Inc.
- *
+ * Copyright 2011 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.dev.javac.rebind;
+package com.google.gwt.dev.javac;
 
+import com.google.gwt.core.ext.CachedGeneratorResult;
 import com.google.gwt.core.ext.linker.ArtifactSet;
-import com.google.gwt.dev.javac.GeneratedUnit;
 
 import java.io.Serializable;
 import java.util.Collection;
@@ -24,36 +24,37 @@
 import java.util.Map;
 
 /**
- * A class to represent the results from a rebind operation.  This can be
- * cached and presented to subsequent rebind operations, providing the generator
- * information needed to decide whether full or partial re-generation is required.
+ * An implementation class to represent the cached results from a previous
+ * generator invocation.
  */
-public class CachedRebindResult implements Serializable {
+public class CachedGeneratorResultImpl implements CachedGeneratorResult, Serializable {
   private final ArtifactSet artifacts;
   private final Map<String, GeneratedUnit> generatedUnitMap;
-  private final String returnedTypeName;
+  private final String resultTypeName;
   private final long timeGenerated;
-  private final CachedClientDataMap clientDataMap;
+  private final Map<String, Serializable> clientDataMap;
 
-  public CachedRebindResult(String resultTypeName, ArtifactSet artifacts, 
-      Map<String, GeneratedUnit> generatedUnitMap, 
-      long timeGenerated, CachedClientDataMap clientDataMap) {
-    this.returnedTypeName = resultTypeName;
+  public CachedGeneratorResultImpl(String resultTypeName, ArtifactSet artifacts,
+      Map<String, GeneratedUnit> generatedUnitMap, long timeGenerated,
+      Map<String, Serializable> clientDataMap) {
+    this.resultTypeName = resultTypeName;
     this.artifacts = new ArtifactSet(artifacts);
     this.generatedUnitMap = new HashMap<String, GeneratedUnit>(generatedUnitMap);
     this.timeGenerated = timeGenerated;
+    assert clientDataMap instanceof Serializable;
     this.clientDataMap = clientDataMap;
   }
-  
-  public CachedRebindResult(String resultTypeName, ArtifactSet artifacts, 
+
+  public CachedGeneratorResultImpl(String resultTypeName, ArtifactSet artifacts,
       Map<String, GeneratedUnit> generatedUnitMap, long timeGenerated) {
     this(resultTypeName, artifacts, generatedUnitMap, timeGenerated, null);
   }
-  
+
   public ArtifactSet getArtifacts() {
     return artifacts;
   }
-  
+
+  @Override
   public Object getClientData(String key) {
     if (clientDataMap == null) {
       return null;
@@ -61,27 +62,26 @@
       return clientDataMap.get(key);
     }
   }
-  
-  public CachedClientDataMap getClientDataMap() {
-    return clientDataMap;
-  }
-  
+
   public GeneratedUnit getGeneratedUnit(String typeName) {
     return generatedUnitMap.get(typeName);
   }
-  
+
   public Collection<GeneratedUnit> getGeneratedUnits() {
     return generatedUnitMap.values();
   }
-  
-  public String getReturnedTypeName() {
-    return returnedTypeName;
+
+  @Override
+  public String getResultTypeName() {
+    return resultTypeName;
   }
-  
+
+  @Override
   public long getTimeGenerated() {
     return timeGenerated;
   }
-  
+
+  @Override
   public boolean isTypeCached(String typeName) {
     return generatedUnitMap.containsKey(typeName);
   }
diff --git a/dev/core/src/com/google/gwt/dev/javac/StandardGeneratorContext.java b/dev/core/src/com/google/gwt/dev/javac/StandardGeneratorContext.java
index ae94764..b19eb9a 100644
--- a/dev/core/src/com/google/gwt/dev/javac/StandardGeneratorContext.java
+++ b/dev/core/src/com/google/gwt/dev/javac/StandardGeneratorContext.java
@@ -15,12 +15,13 @@
  */
 package com.google.gwt.dev.javac;
 
+import com.google.gwt.core.ext.CachedGeneratorResult;
 import com.google.gwt.core.ext.Generator;
 import com.google.gwt.core.ext.GeneratorContext;
-import com.google.gwt.core.ext.GeneratorContextExt;
-import com.google.gwt.core.ext.GeneratorExt;
-import com.google.gwt.core.ext.GeneratorExtWrapper;
+import com.google.gwt.core.ext.IncrementalGenerator;
 import com.google.gwt.core.ext.PropertyOracle;
+import com.google.gwt.core.ext.RebindResult;
+import com.google.gwt.core.ext.RebindRuleResolver;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.core.ext.linker.Artifact;
@@ -30,10 +31,6 @@
 import com.google.gwt.core.ext.typeinfo.JClassType;
 import com.google.gwt.core.ext.typeinfo.TypeOracle;
 import com.google.gwt.dev.cfg.ModuleDef;
-import com.google.gwt.dev.javac.rebind.CachedRebindResult;
-import com.google.gwt.dev.javac.rebind.RebindResult;
-import com.google.gwt.dev.javac.rebind.RebindRuleResolver;
-import com.google.gwt.dev.javac.rebind.RebindStatus;
 import com.google.gwt.dev.resource.ResourceOracle;
 import com.google.gwt.dev.util.DiskCache;
 import com.google.gwt.dev.util.Util;
@@ -63,7 +60,7 @@
 /**
  * Manages generators and generated units during a single compilation.
  */
-public class StandardGeneratorContext implements GeneratorContextExt {
+public class StandardGeneratorContext implements GeneratorContext {
 
   /**
    * Extras added to {@link GeneratedUnit}.
@@ -72,13 +69,6 @@
     void abort();
 
     void commit(TreeLogger logger);
-
-    /**
-     * Returns the strong hash of the source.
-     */
-    String getStrongHash();
-
-    String getTypeName();
   }
 
   /**
@@ -107,6 +97,7 @@
       this.sw = sw;
     }
 
+    @Override
     public void abort() {
       sw = null;
     }
@@ -114,6 +105,7 @@
     /**
      * Finalizes the source and adds this generated unit to the host.
      */
+    @Override
     public void commit(TreeLogger logger) {
       String source = sw.toString();
       strongHash = Util.computeStrongName(Util.getBytes(source));
@@ -122,10 +114,12 @@
       creationTime = System.currentTimeMillis();
     }
 
+    @Override
     public long creationTime() {
       return creationTime;
     }
 
+    @Override
     public String getSource() {
       if (sw != null) {
         throw new IllegalStateException("source not committed");
@@ -133,6 +127,7 @@
       return diskCache.readString(sourceToken);
     }
 
+    @Override
     public long getSourceToken() {
       if (sw != null) {
         throw new IllegalStateException("source not committed");
@@ -140,14 +135,17 @@
       return sourceToken;
     }
 
+    @Override
     public String getStrongHash() {
       return strongHash;
     }
 
+    @Override
     public String getTypeName() {
       return typeName;
     }
 
+    @Override
     public String optionalFileLocation() {
       return null;
     }
@@ -239,6 +237,8 @@
     }
   }
 
+  private static final String GENERATOR_VERSION_ID_KEY = "generator-version-id";
+
   private static DiskCache diskCache = DiskCache.INSTANCE;
 
   private static final Map<String, CompilerEventType> eventsByGeneratorType =
@@ -295,7 +295,7 @@
   private final Map<PrintWriter, Generated> uncommittedGeneratedCupsByPrintWriter =
       new IdentityHashMap<PrintWriter, Generated>();
 
-  private CachedRebindResult cachedRebindResult = null;
+  private CachedGeneratorResultImpl cachedRebindResult = null;
 
   private boolean generatorResultCachingEnabled = false;
 
@@ -364,6 +364,7 @@
   /**
    * Checks whether a rebind rule is available for a given sourceTypeName.
    */
+  @Override
   public boolean checkRebindRuleAvailable(String sourceTypeName) {
     if (rebindRuleResolver != null) {
       return rebindRuleResolver.checkRebindRuleResolvable(sourceTypeName);
@@ -383,6 +384,7 @@
   /**
    * Commits a pending generated type.
    */
+  @Override
   public final void commit(TreeLogger logger, PrintWriter pw) {
     Generated gcup = uncommittedGeneratedCupsByPrintWriter.get(pw);
     if (gcup != null) {
@@ -401,6 +403,7 @@
    * that only new entries will ever be inserted here for a given generator
    * run).
    */
+  @Override
   public void commitArtifact(TreeLogger logger, Artifact<?> artifact) {
     allGeneratedArtifacts.replace(artifact);
     newlyGeneratedArtifacts.add(artifact);
@@ -417,6 +420,7 @@
     }
   }
 
+  @Override
   public GeneratedResource commitResource(TreeLogger logger, OutputStream os)
       throws UnableToCompleteException {
 
@@ -493,7 +497,6 @@
       committedGeneratedCups.clear();
       newlyGeneratedTypeNames.clear();
       newlyGeneratedArtifacts = new ArtifactSet();
-      cachedRebindResult = null;
       cachedTypeNamesToReuse = null;
     }
   }
@@ -512,7 +515,8 @@
   /**
    * Gets the previously cached rebind result for the current generator.
    */
-  public CachedRebindResult getCachedGeneratorResult() {
+  @Override
+  public CachedGeneratorResult getCachedGeneratorResult() {
     return cachedRebindResult;
   }
 
@@ -531,49 +535,32 @@
     return committedGeneratedCups;
   }
 
+  @Override
   public final PropertyOracle getPropertyOracle() {
     return propOracle;
   }
 
+  @Override
   public ResourceOracle getResourcesOracle() {
     return module.getResourcesOracle();
   }
 
+  @Override
   public final TypeOracle getTypeOracle() {
     return compilationState.getTypeOracle();
   }
 
+  @Override
   public boolean isGeneratorResultCachingEnabled() {
     return generatorResultCachingEnabled;
   }
 
+  @Override
   public boolean isProdMode() {
     return isProdMode;
   }
 
   /**
-   * Adds a type name to the list of types to be reused from cache, if
-   * available.
-   * 
-   * @param typeName The fully qualified name of a type.
-   * 
-   * @return true, if the type is available in the cache and was successfully
-   *         added to the list for reuse, false otherwise.
-   */
-  public boolean reuseTypeFromCacheIfAvailable(String typeName) {
-    if (!isGeneratorResultCachingEnabled() || cachedRebindResult == null
-        || !cachedRebindResult.isTypeCached(typeName)) {
-      return false;
-    }
-
-    if (cachedTypeNamesToReuse == null) {
-      cachedTypeNamesToReuse = new ArrayList<String>();
-    }
-    cachedTypeNamesToReuse.add(typeName);
-    return true;
-  }
-
-  /**
    * This method is maintained for backwards compatibility.
    * {@link #runGeneratorIncrementally} should be used instead.
    */
@@ -582,20 +569,21 @@
 
     RebindResult result = runGeneratorIncrementally(logger, generatorClass, typeName);
 
-    return result.getReturnedTypeName();
+    return result.getResultTypeName();
   }
 
   /**
    * Runs a generator incrementally, with support for managing the returned
-   * {@link RebindResult} object, which can contain status and cached results.
-   * This is a replacement for the {@link #runGenerator} method.
+   * {@link RebindResult} object, which can contain cached results. This is a
+   * replacement for the {@link #runGenerator} method.
    * <p>
-   * If the passed in generatorClass is an instance of {@link GeneratorExt},
-   * it's {@link GeneratorExt#generateIncrementally} method will be called.
+   * If the passed in generatorClass is an instance of
+   * {@link IncrementalGenerator}, it's
+   * {@link IncrementalGenerator#generateIncrementally} method will be called.
    * <p>
    * Otherwise, for backwards compatibility, the generatorClass will be wrapped
-   * in a {@link GeneratorExt} instance, and it's {@link Generator#generate}
-   * method will be called.
+   * in a {@link IncrementalGenerator} instance, and it's
+   * {@link Generator#generate} method will be called.
    * 
    * @param logger
    * @param generatorClass
@@ -625,6 +613,7 @@
     // Avoid call to System.currentTimeMillis() if not logging DEBUG level
     boolean loggable = logger.isLoggable(TreeLogger.DEBUG);
     long before = loggable ? System.currentTimeMillis() : 0L;
+
     String generatorClassName = generator.getClass().getName();
     CompilerEventType type = eventsByGeneratorType.get(generatorClassName);
 
@@ -636,24 +625,38 @@
         SpeedTracerLogger.start(type, "class", generatorClassName, "type", typeName);
 
     try {
-      GeneratorExt generatorExt;
-      if (generator instanceof GeneratorExt) {
-        generatorExt = (GeneratorExt) generator;
+      RebindResult result;
+      if (generator instanceof IncrementalGenerator) {
+        IncrementalGenerator incGenerator = (IncrementalGenerator) generator;
+
+        // check version id for any previously cached rebind result
+        if (cachedRebindResult != null) {
+          Long cachedVersionId = (Long) cachedRebindResult.getClientData(GENERATOR_VERSION_ID_KEY);
+          if (cachedVersionId != null && cachedVersionId != incGenerator.getVersionId()) {
+            // remove from context
+            if (logger.isLoggable(TreeLogger.TRACE)) {
+              logger.log(TreeLogger.TRACE, "Got version mismatch with cached generator result for "
+                  + typeName + ", invalidating cached result");
+            }
+            cachedRebindResult = null;
+          }
+        }
+
+        // run the generator
+        result = incGenerator.generateIncrementally(logger, this, typeName);
+
+        // add version id to the returned result
+        result.putClientData(GENERATOR_VERSION_ID_KEY, incGenerator.getVersionId());
       } else {
-        generatorExt = GeneratorExtWrapper.newInstance(generator);
+        // run a non-incremental generator
+        result = IncrementalGenerator.generateNonIncrementally(logger, generator, this, typeName);
       }
 
-      RebindResult result;
-      result = generatorExt.generateIncrementally(logger, this, typeName);
-
       if (loggable) {
-        if (result.getResultStatus() == RebindStatus.USE_EXISTING) {
-          msg = "Generator did not return a new class, type will be used as is";
-        } else {
-          msg = "Generator returned class '" + result.getReturnedTypeName() + "'";
-        }
         long after = System.currentTimeMillis();
-        msg += "; in " + (after - before) + " ms";
+        msg =
+            "Generator returned type '" + result.getResultTypeName() + "; mode "
+                + result.getRebindMode() + "; in " + (after - before) + " ms";
         logger.log(TreeLogger.DEBUG, msg, null);
       }
       return result;
@@ -674,8 +677,8 @@
   /**
    * Set previously cached rebind result for currently active generator.
    */
-  public void setCachedGeneratorResult(CachedRebindResult cachedRebindResult) {
-    this.cachedRebindResult = cachedRebindResult;
+  public void setCachedGeneratorResult(CachedGeneratorResult cachedRebindResult) {
+    this.cachedRebindResult = (CachedGeneratorResultImpl) cachedRebindResult;
   }
 
   public void setCurrentGenerator(Class<? extends Generator> currentGenerator) {
@@ -698,6 +701,7 @@
     this.rebindRuleResolver = resolver;
   }
 
+  @Override
   public final PrintWriter tryCreate(TreeLogger logger, String packageName, String simpleTypeName) {
     String typeName;
     if (packageName.length() == 0) {
@@ -752,6 +756,7 @@
     return pw;
   }
 
+  @Override
   public OutputStream tryCreateResource(TreeLogger logger, String partialPath)
       throws UnableToCompleteException {
 
@@ -810,6 +815,29 @@
     return pendingResource;
   }
 
+  /**
+   * Adds a type name to the list of types to be reused from cache, if
+   * available.
+   * 
+   * @param typeName The fully qualified name of a type.
+   * 
+   * @return true, if the type is available in the cache and was successfully
+   *         added to the list for reuse, false otherwise.
+   */
+  @Override
+  public boolean tryReuseTypeFromCache(String typeName) {
+    if (!isGeneratorResultCachingEnabled() || cachedRebindResult == null
+        || !cachedRebindResult.isTypeCached(typeName)) {
+      return false;
+    }
+
+    if (cachedTypeNamesToReuse == null) {
+      cachedTypeNamesToReuse = new ArrayList<String>();
+    }
+    cachedTypeNamesToReuse.add(typeName);
+    return true;
+  }
+
   private void abortUncommittedResources(TreeLogger logger) {
     if (pendingResources.isEmpty()) {
       // Nothing to do.
diff --git a/dev/core/src/com/google/gwt/dev/javac/rebind/CachedClientDataMap.java b/dev/core/src/com/google/gwt/dev/javac/rebind/CachedClientDataMap.java
deleted file mode 100644
index c7b0d3d..0000000
--- a/dev/core/src/com/google/gwt/dev/javac/rebind/CachedClientDataMap.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2011 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.dev.javac.rebind;
-
-import java.io.Serializable;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * A simple map class for storing cached rebind client data.  It ensures that
- * all stored data implement Serializable.
- */
-public class CachedClientDataMap implements Serializable {
-  
-  private final Map<String, Serializable> dataMap;
-  
-  public CachedClientDataMap() {
-    dataMap = new HashMap<String, Serializable>();
-  }
-  
-  public Object get(String key) {
-    return dataMap.get(key);
-  }
-  
-  public void put(String key, Object value) {
-    dataMap.put(key, (Serializable) value);
-  }
-}
diff --git a/dev/core/src/com/google/gwt/dev/javac/rebind/RebindResult.java b/dev/core/src/com/google/gwt/dev/javac/rebind/RebindResult.java
deleted file mode 100644
index 377c679..0000000
--- a/dev/core/src/com/google/gwt/dev/javac/rebind/RebindResult.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright 2010 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.dev.javac.rebind;
-
-/**
- * A class for returning the result of a rebind operation.
- */
-public class RebindResult {
-  private final RebindStatus resultStatus;
-  private final String returnedTypeName;
-  private final CachedClientDataMap clientData;
- 
-  public RebindResult(RebindStatus resultStatus, 
-      String returnedType, CachedClientDataMap clientData) {
-    this.resultStatus = resultStatus;
-    this.returnedTypeName = returnedType;
-    this.clientData = clientData;
-  }
-
-  public RebindResult(RebindStatus resultStatus, String returnedType) {
-    this(resultStatus, returnedType, null);
-  }
- 
-  public Object getClientData(String key) {
-    if (clientData == null) {
-      return null;
-    } else {
-      return clientData.get(key);
-    }
-  }
- 
-  public CachedClientDataMap getClientDataMap() {
-    return clientData;
-  }
- 
-  public RebindStatus getResultStatus() {
-    return resultStatus;
-  }
-
-  public String getReturnedTypeName() {
-    return returnedTypeName;
-  }
-}
diff --git a/dev/core/src/com/google/gwt/dev/javac/rebind/RebindStatus.java b/dev/core/src/com/google/gwt/dev/javac/rebind/RebindStatus.java
deleted file mode 100644
index 3506723..0000000
--- a/dev/core/src/com/google/gwt/dev/javac/rebind/RebindStatus.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright 2010 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.dev.javac.rebind;
-
-/**
- * The returned status for a rebind result.  This status is used by the 
- * {@link com.google.gwt.dev.shell.StandardRebindOracle} implementation to 
- * determine how to integrate the result into the system.  In the descriptions 
- * below, the "products" of a rebind result can include updated type 
- * information, newly generated artifacts, and newly generated compilation units.
- */
-public enum RebindStatus {
- 
-  /**
-   * Indicates nothing new was created, use pre-existing type information.
-   */ 
-  USE_EXISTING,
- 
-  /**
-   * Indicates only newly generated products should be used.
-   */
-  USE_ALL_NEW,
-  
-  /**
-   * Indicates only newly generated products should be used, and no results
-   * should be cached, such as in the case where no caching can be taken
-   * advantage of.
-   */
-  USE_ALL_NEW_WITH_NO_CACHING,
-  
-  /**
-   * Indicates only previously cached products should be used.
-   */
-  USE_ALL_CACHED,
-  
-  /**
-   * Indicates that a mixture of newly generated and previously cached products
-   * should be used.
-   */
-  USE_PARTIAL_CACHED
-}
diff --git a/dev/core/src/com/google/gwt/dev/shell/ShellModuleSpaceHost.java b/dev/core/src/com/google/gwt/dev/shell/ShellModuleSpaceHost.java
index e5ac9b4..07e03ef 100644
--- a/dev/core/src/com/google/gwt/dev/shell/ShellModuleSpaceHost.java
+++ b/dev/core/src/com/google/gwt/dev/shell/ShellModuleSpaceHost.java
@@ -18,11 +18,11 @@
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.core.ext.linker.ArtifactSet;
+import com.google.gwt.dev.RebindCache;
 import com.google.gwt.dev.cfg.ModuleDef;
 import com.google.gwt.dev.cfg.Rules;
 import com.google.gwt.dev.javac.CompilationState;
 import com.google.gwt.dev.javac.StandardGeneratorContext;
-import com.google.gwt.dev.javac.rebind.RebindCache;
 import com.google.gwt.dev.util.log.speedtracer.DevModeEventType;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event;
diff --git a/dev/core/src/com/google/gwt/dev/shell/StandardRebindOracle.java b/dev/core/src/com/google/gwt/dev/shell/StandardRebindOracle.java
index 8449fee..e9cc7a8 100644
--- a/dev/core/src/com/google/gwt/dev/shell/StandardRebindOracle.java
+++ b/dev/core/src/com/google/gwt/dev/shell/StandardRebindOracle.java
@@ -15,18 +15,19 @@
  */
 package com.google.gwt.dev.shell;
 
+import com.google.gwt.core.ext.CachedGeneratorResult;
 import com.google.gwt.core.ext.PropertyOracle;
+import com.google.gwt.core.ext.RebindMode;
+import com.google.gwt.core.ext.RebindResult;
+import com.google.gwt.core.ext.RebindRuleResolver;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.core.ext.linker.ArtifactSet;
+import com.google.gwt.dev.RebindCache;
 import com.google.gwt.dev.cfg.Rule;
 import com.google.gwt.dev.cfg.Rules;
+import com.google.gwt.dev.javac.CachedGeneratorResultImpl;
 import com.google.gwt.dev.javac.StandardGeneratorContext;
-import com.google.gwt.dev.javac.rebind.CachedRebindResult;
-import com.google.gwt.dev.javac.rebind.RebindCache;
-import com.google.gwt.dev.javac.rebind.RebindResult;
-import com.google.gwt.dev.javac.rebind.RebindRuleResolver;
-import com.google.gwt.dev.javac.rebind.RebindStatus;
 import com.google.gwt.dev.jdt.RebindOracle;
 import com.google.gwt.dev.util.log.speedtracer.DevModeEventType;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
@@ -69,7 +70,7 @@
           return typeName;
         }
 
-        CachedRebindResult cachedResult = rebindCacheGet(rule, typeName);
+        CachedGeneratorResult cachedResult = rebindCacheGet(rule, typeName);
         if (cachedResult != null) {
           genCtx.setCachedGeneratorResult(cachedResult);
         }
@@ -164,16 +165,16 @@
      * to cache the new result for the future.
      */
     private String processCacheableResult(TreeLogger logger, Rule rule, String typeName,
-        CachedRebindResult cachedResult, RebindResult newResult) {
+        CachedGeneratorResult cachedResult, RebindResult newResult) {
 
-      String resultTypeName = newResult.getReturnedTypeName();
+      String resultTypeName = newResult.getResultTypeName();
 
       if (!genCtx.isGeneratorResultCachingEnabled()) {
         return resultTypeName;
       }
 
-      RebindStatus status = newResult.getResultStatus();
-      switch (status) {
+      RebindMode mode = newResult.getRebindMode();
+      switch (mode) {
 
         case USE_EXISTING:
           // in this case, no newly generated or cached types are needed
@@ -190,8 +191,9 @@
         case USE_ALL_NEW:
           // use all new results, add a new cache entry
           cachedResult =
-              new CachedRebindResult(newResult.getReturnedTypeName(), genCtx.getArtifacts(), genCtx
-                  .getGeneratedUnitMap(), System.currentTimeMillis(), newResult.getClientDataMap());
+              new CachedGeneratorResultImpl(newResult.getResultTypeName(), genCtx.getArtifacts(),
+                  genCtx.getGeneratedUnitMap(), System.currentTimeMillis(), newResult
+                      .getClientDataMap());
           rebindCachePut(rule, typeName, cachedResult);
           break;
 
@@ -203,7 +205,7 @@
           genCtx.addGeneratedUnitsFromCache();
 
           // use cached type name
-          resultTypeName = cachedResult.getReturnedTypeName();
+          resultTypeName = cachedResult.getResultTypeName();
           break;
 
         case USE_PARTIAL_CACHED:
@@ -219,11 +221,16 @@
            * cached results currently in genCtx.
            */
           cachedResult =
-              new CachedRebindResult(newResult.getReturnedTypeName(), genCtx.getArtifacts(), genCtx
-                  .getGeneratedUnitMap(), System.currentTimeMillis(), newResult.getClientDataMap());
+              new CachedGeneratorResultImpl(newResult.getResultTypeName(), genCtx.getArtifacts(),
+                  genCtx.getGeneratedUnitMap(), System.currentTimeMillis(), newResult
+                      .getClientDataMap());
           rebindCachePut(rule, typeName, cachedResult);
           break;
       }
+
+      // clear the current cached result
+      genCtx.setCachedGeneratorResult(null);
+
       return resultTypeName;
     }
   }
@@ -253,6 +260,7 @@
     typeNameBindingMap.remove(sourceTypeName);
   }
 
+  @Override
   public String rebind(TreeLogger logger, String typeName) throws UnableToCompleteException {
     return rebind(logger, typeName, null);
   }
@@ -277,14 +285,14 @@
     this.rebindCache = cache;
   }
 
-  private CachedRebindResult rebindCacheGet(Rule rule, String typeName) {
+  private CachedGeneratorResult rebindCacheGet(Rule rule, String typeName) {
     if (rebindCache != null) {
       return rebindCache.get(rule, typeName);
     }
     return null;
   }
 
-  private void rebindCachePut(Rule rule, String typeName, CachedRebindResult result) {
+  private void rebindCachePut(Rule rule, String typeName, CachedGeneratorResult result) {
     if (rebindCache != null) {
       rebindCache.put(rule, typeName, result);
     }
diff --git a/user/src/com/google/gwt/i18n/rebind/CachedGeneratorContext.java b/user/src/com/google/gwt/i18n/rebind/CachedGeneratorContext.java
index e786bec..e972d43 100644
--- a/user/src/com/google/gwt/i18n/rebind/CachedGeneratorContext.java
+++ b/user/src/com/google/gwt/i18n/rebind/CachedGeneratorContext.java
@@ -15,14 +15,10 @@
  */
 package com.google.gwt.i18n.rebind;
 
+import com.google.gwt.core.ext.DelegatingGeneratorContext;
 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.linker.Artifact;
-import com.google.gwt.core.ext.linker.GeneratedResource;
-import com.google.gwt.core.ext.typeinfo.TypeOracle;
-import com.google.gwt.dev.resource.ResourceOracle;
 
 import java.io.OutputStream;
 import java.io.PrintWriter;
@@ -35,45 +31,16 @@
  * run. This is needed when one generator calls other generators multiple times
  * (such as for runtime locale support).
  */
-class CachedGeneratorContext implements GeneratorContext {
+class CachedGeneratorContext extends DelegatingGeneratorContext {
   private final GeneratorContext context;
   private Set<String> generatedResources = new HashSet<String>();
   private Set<String> generatedTypes = new HashSet<String>();
 
   CachedGeneratorContext(GeneratorContext context) {
+    super(context);
     this.context = context;
   }
 
-  public boolean checkRebindRuleAvailable(String sourceTypeName) {
-    return context.checkRebindRuleAvailable(sourceTypeName);
-  }
-
-  public void commit(TreeLogger logger, PrintWriter pw) {
-    context.commit(logger, pw);
-  }
-
-  public void commitArtifact(TreeLogger logger, Artifact<?> artifact)
-      throws UnableToCompleteException {
-    context.commitArtifact(logger, artifact);
-  }
-
-  public GeneratedResource commitResource(TreeLogger logger, OutputStream os)
-      throws UnableToCompleteException {
-    return context.commitResource(logger, os);
-  }
-
-  public PropertyOracle getPropertyOracle() {
-    return context.getPropertyOracle();
-  }
-
-  public ResourceOracle getResourcesOracle() {
-    return context.getResourcesOracle();
-  }
-
-  public TypeOracle getTypeOracle() {
-    return context.getTypeOracle();
-  }
-
   /**
    * Provide the canonical context represented by this context.
    * 
@@ -83,6 +50,7 @@
     return context;
   }
 
+  @Override
   public PrintWriter tryCreate(TreeLogger logger, String packageName, String simpleName) {
     String typeName = packageName + '.' + simpleName;
     if (generatedTypes.contains(typeName)) {
@@ -92,6 +60,7 @@
     return context.tryCreate(logger, packageName, simpleName);
   }
 
+  @Override
   public OutputStream tryCreateResource(TreeLogger logger, String partialPath)
       throws UnableToCompleteException {
     if (generatedResources.contains(partialPath)) {
diff --git a/user/src/com/google/gwt/resources/rebind/context/AbstractClientBundleGenerator.java b/user/src/com/google/gwt/resources/rebind/context/AbstractClientBundleGenerator.java
index 489c3c5..69b78d6 100644
--- a/user/src/com/google/gwt/resources/rebind/context/AbstractClientBundleGenerator.java
+++ b/user/src/com/google/gwt/resources/rebind/context/AbstractClientBundleGenerator.java
@@ -17,10 +17,13 @@
 
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.core.ext.BadPropertyValueException;
+import com.google.gwt.core.ext.CachedPropertyInformation;
+import com.google.gwt.core.ext.CachedGeneratorResult;
 import com.google.gwt.core.ext.GeneratorContext;
-import com.google.gwt.core.ext.GeneratorContextExt;
-import com.google.gwt.core.ext.GeneratorExt;
+import com.google.gwt.core.ext.IncrementalGenerator;
 import com.google.gwt.core.ext.PropertyOracle;
+import com.google.gwt.core.ext.RebindMode;
+import com.google.gwt.core.ext.RebindResult;
 import com.google.gwt.core.ext.SelectionProperty;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
@@ -32,11 +35,6 @@
 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.javac.rebind.CachedClientDataMap;
-import com.google.gwt.dev.javac.rebind.CachedPropertyInformation;
-import com.google.gwt.dev.javac.rebind.CachedRebindResult;
-import com.google.gwt.dev.javac.rebind.RebindResult;
-import com.google.gwt.dev.javac.rebind.RebindStatus;
 import com.google.gwt.dev.util.Util;
 import com.google.gwt.resources.client.ClientBundle;
 import com.google.gwt.resources.client.ClientBundleWithLookup;
@@ -53,6 +51,7 @@
 import com.google.gwt.user.rebind.SourceWriter;
 
 import java.io.PrintWriter;
+import java.io.Serializable;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -114,12 +113,21 @@
  * of an instance of the ClientBundle type so that resources can refer to one
  * another by simply emitting a call to <code>resource()</code>.
  */
-public abstract class AbstractClientBundleGenerator extends GeneratorExt {
+public abstract class AbstractClientBundleGenerator extends IncrementalGenerator {
   private static final String CACHED_PROPERTY_INFORMATION = "cached-property-info";
   private static final String CACHED_RESOURCE_INFORMATION = "cached-resource-info";
   private static final String CACHED_TYPE_INFORMATION = "cached-type-info";
   private static final String INSTANCE_NAME = "_instance0";
 
+  /*
+   * A version id. Increment this as needed, when structural changes are made to
+   * the generated output, specifically with respect to it's effect on the
+   * caching and reuse of previous generator results. Previously cached
+   * generator results will be invalidated automatically if they were generated
+   * by a version of this generator with a different version id.
+   */
+  private static final long GENERATOR_VERSION_ID = 1L;
+
   /**
    * An implementation of ClientBundleFields.
    */
@@ -324,18 +332,17 @@
   }
 
   @Override
-  public RebindResult generateIncrementally(TreeLogger logger,
-      GeneratorContextExt generatorContext, String typeName)
-      throws UnableToCompleteException {
+  public RebindResult generateIncrementally(TreeLogger logger, GeneratorContext generatorContext, 
+        String typeName) throws UnableToCompleteException {
 
     /*
      * Do a series of checks to see if we can use a previously cached result,
      * and if so, we can skip further execution and return immediately.
      */
     boolean useCache = false;
-    if (checkPropertyCacheability(logger, generatorContext)
-        && checkSourceTypeCacheability(logger, generatorContext)
-        && checkDependentResourceCacheability(logger, generatorContext)) {
+    if (checkCachedPropertyInformation(logger, generatorContext)
+        && checkCachedSourceTypes(logger, generatorContext)
+        && checkCachedDependentResources(logger, generatorContext)) {
       useCache = true;
     }
     
@@ -352,7 +359,7 @@
     }
       
     if (useCache) {
-      return new RebindResult(RebindStatus.USE_ALL_CACHED, typeName);
+      return new RebindResult(RebindMode.USE_ALL_CACHED, typeName);
     }
       
     // The TypeOracle knows about all types in the type system
@@ -488,21 +495,27 @@
       // remember the required resources
       Map<String, URL> cri = requirements.getResolvedResources();
 
-      // create data map to be returned the next time the generator is run
-      CachedClientDataMap data = new CachedClientDataMap();
-      data.put(CACHED_PROPERTY_INFORMATION, cpi);
-      data.put(CACHED_RESOURCE_INFORMATION, cri);
-      data.put(CACHED_TYPE_INFORMATION, cti);
+      // create a new cacheable result
+      RebindResult result = new RebindResult(RebindMode.USE_ALL_NEW, createdClassName);
 
-      // Return a new cacheable result
-      return new RebindResult(RebindStatus.USE_ALL_NEW, createdClassName, data);
+      // add data to be returned the next time the generator is run
+      result.putClientData(CACHED_PROPERTY_INFORMATION, cpi);
+      result.putClientData(CACHED_RESOURCE_INFORMATION, (Serializable) cri);
+      result.putClientData(CACHED_TYPE_INFORMATION, (Serializable) cti);
+
+      return result;
     } else {
       // If we can't be cacheable, don't return a cacheable result
-      return new RebindResult(RebindStatus.USE_ALL_NEW_WITH_NO_CACHING,
+      return new RebindResult(RebindMode.USE_ALL_NEW_WITH_NO_CACHING,
           createdClassName);
     }
   }
 
+  @Override
+  public long getVersionId() {
+    return GENERATOR_VERSION_ID;
+  }
+
   /**
    * Create the ResourceContext object that will be used by
    * {@link ResourceGenerator} subclasses. This is the primary way to implement
@@ -555,40 +568,12 @@
   }
 
   /**
-   * Check that the cached last modified times match those from the current
-   * typeOracle.
+   * Check cached dependent resources.
    */
-  private boolean checkCachedTypeLastModifiedTimes(TreeLogger logger,
-      GeneratorContextExt generatorContext, Map<String, Long> typeLastModifiedTimes) {
-    
-    TypeOracle oracle = generatorContext.getTypeOracle();
-    
-    for (String sourceTypeName : typeLastModifiedTimes.keySet()) {
-      JClassType sourceType = oracle.findType(sourceTypeName);
-      if (sourceType == null) {
-        logger.log(TreeLogger.TRACE, 
-            "Found previously dependent type that's no longer present: " + sourceTypeName);
-        return false;
-      }
-      assert sourceType instanceof JRealClassType;
-      JRealClassType sourceRealType = (JRealClassType) sourceType;
-      
-      if (sourceRealType.getLastModifiedTime() != typeLastModifiedTimes.get(sourceTypeName)) {
-        logger.log(TreeLogger.TRACE, "Found dependent type that has changed: " + sourceTypeName);
-        return false;
-      }
-    }
-    
-    return true;
-  }
+  private boolean checkCachedDependentResources(TreeLogger logger,
+      GeneratorContext genContext) {
 
-  /**
-   * Check dependent resources for cacheability.
-   */
-  private boolean checkDependentResourceCacheability(TreeLogger logger,
-      GeneratorContextExt genContext) {
-
-    CachedRebindResult lastRebindResult = genContext.getCachedGeneratorResult();
+    CachedGeneratorResult lastRebindResult = genContext.getCachedGeneratorResult();
 
     if (lastRebindResult == null 
         || !genContext.isGeneratorResultCachingEnabled()) {
@@ -636,13 +621,12 @@
     return true;
   }
 
-  /*
-   * Check properties for cacheability
+  /**
+   * Check cached properties.
    */
-  private boolean checkPropertyCacheability(TreeLogger logger,
-      GeneratorContextExt genContext) {
+  private boolean checkCachedPropertyInformation(TreeLogger logger, GeneratorContext genContext) {
 
-    CachedRebindResult lastRebindResult = genContext.getCachedGeneratorResult();
+    CachedGeneratorResult lastRebindResult = genContext.getCachedGeneratorResult();
 
     if (lastRebindResult == null 
         || !genContext.isGeneratorResultCachingEnabled()) {
@@ -659,36 +643,13 @@
     return cpi != null && cpi.checkPropertiesWithPropertyOracle(logger, 
         genContext.getPropertyOracle());
   }
-  
+
   /**
-   * Check cacheability for resource generators in taskList.
+   * Check cached source types.
    */
-  private boolean checkResourceGeneratorCacheability(
-      GeneratorContextExt genContext,
-      Map<Class<? extends ResourceGenerator>, List<JMethod>> taskList) {
-    
-    if (!genContext.isGeneratorResultCachingEnabled()) {
-      return false;
-    }
+  private boolean checkCachedSourceTypes(TreeLogger logger, GeneratorContext genContext) {
 
-    /*
-     * Loop through each of our ResouceGenerator classes, and check those that
-     * implement the SupportsGeneratorResultCaching interface.
-     */
-    for (Class<? extends ResourceGenerator> rgClass : taskList.keySet()) {
-      if (!SupportsGeneratorResultCaching.class.isAssignableFrom(rgClass)) {
-        return false;
-      }
-    } 
-    return true;
-  }
-
-  /*
-   * Check source types for cacheability
-   */
-  private boolean checkSourceTypeCacheability(TreeLogger logger, GeneratorContextExt genContext) {
-
-    CachedRebindResult lastRebindResult = genContext.getCachedGeneratorResult();
+    CachedGeneratorResult lastRebindResult = genContext.getCachedGeneratorResult();
 
     if (lastRebindResult == null 
         || !genContext.isGeneratorResultCachingEnabled()) {
@@ -709,6 +670,56 @@
   }
 
   /**
+   * Check that the cached last modified times match those from the current
+   * typeOracle.
+   */
+  private boolean checkCachedTypeLastModifiedTimes(TreeLogger logger,
+      GeneratorContext generatorContext, Map<String, Long> typeLastModifiedTimes) {
+    
+    TypeOracle oracle = generatorContext.getTypeOracle();
+    
+    for (String sourceTypeName : typeLastModifiedTimes.keySet()) {
+      JClassType sourceType = oracle.findType(sourceTypeName);
+      if (sourceType == null) {
+        logger.log(TreeLogger.TRACE, 
+            "Found previously dependent type that's no longer present: " + sourceTypeName);
+        return false;
+      }
+      assert sourceType instanceof JRealClassType;
+      JRealClassType sourceRealType = (JRealClassType) sourceType;
+      
+      if (sourceRealType.getLastModifiedTime() != typeLastModifiedTimes.get(sourceTypeName)) {
+        logger.log(TreeLogger.TRACE, "Found dependent type that has changed: " + sourceTypeName);
+        return false;
+      }
+    }
+    
+    return true;
+  }
+
+  /**
+   * Check cacheability for resource generators in taskList.
+   */
+  private boolean checkResourceGeneratorCacheability(GeneratorContext genContext,
+      Map<Class<? extends ResourceGenerator>, List<JMethod>> taskList) {
+    
+    if (!genContext.isGeneratorResultCachingEnabled()) {
+      return false;
+    }
+
+    /*
+     * Loop through each of our ResouceGenerator classes, and check those that
+     * implement the SupportsGeneratorResultCaching interface.
+     */
+    for (Class<? extends ResourceGenerator> rgClass : taskList.keySet()) {
+      if (!SupportsGeneratorResultCaching.class.isAssignableFrom(rgClass)) {
+        return false;
+      }
+    } 
+    return true;
+  }
+
+  /**
    * Create fields and assignments for a single ResourceGenerator.
    */
   private boolean createFieldsAndAssignments(TreeLogger logger,
diff --git a/user/src/com/google/gwt/rpc/rebind/RpcProxyCreator.java b/user/src/com/google/gwt/rpc/rebind/RpcProxyCreator.java
index 7ea1bac..167a216 100644
--- a/user/src/com/google/gwt/rpc/rebind/RpcProxyCreator.java
+++ b/user/src/com/google/gwt/rpc/rebind/RpcProxyCreator.java
@@ -19,7 +19,7 @@
 import com.google.gwt.core.client.impl.ArtificialRescue;
 import com.google.gwt.core.client.impl.Impl;
 import com.google.gwt.core.client.impl.ArtificialRescue.Rescue;
-import com.google.gwt.core.ext.GeneratorContextExt;
+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.JArrayType;
@@ -118,7 +118,7 @@
   }
 
   @Override
-  protected void generateTypeHandlers(TreeLogger logger, GeneratorContextExt ctx,
+  protected void generateTypeHandlers(TreeLogger logger, GeneratorContext ctx,
       SerializableTypeOracle serializationSto,
       SerializableTypeOracle deserializationSto)
       throws UnableToCompleteException {
@@ -271,7 +271,7 @@
 
   @Override
   protected String writeSerializationPolicyFile(TreeLogger logger,
-      GeneratorContextExt ctx, SerializableTypeOracle serializationSto,
+      GeneratorContext ctx, SerializableTypeOracle serializationSto,
       SerializableTypeOracle deserializationSto)
       throws UnableToCompleteException {
 
diff --git a/user/src/com/google/gwt/user/rebind/rpc/CachedRpcTypeInformation.java b/user/src/com/google/gwt/user/rebind/rpc/CachedRpcTypeInformation.java
index 8429c8c..6ec516c 100644
--- a/user/src/com/google/gwt/user/rebind/rpc/CachedRpcTypeInformation.java
+++ b/user/src/com/google/gwt/user/rebind/rpc/CachedRpcTypeInformation.java
@@ -151,7 +151,7 @@
   }
 
   /*
-   * Finds a last modified time for a type, for testing cacheability.
+   * Finds a last modified time for a type, for testing cache reusability.
    */
   private long getLastModifiedTime(JType type) {
     if (type instanceof JArrayType) {
diff --git a/user/src/com/google/gwt/user/rebind/rpc/FieldSerializerCreator.java b/user/src/com/google/gwt/user/rebind/rpc/FieldSerializerCreator.java
index 2834667..07d3414 100644
--- a/user/src/com/google/gwt/user/rebind/rpc/FieldSerializerCreator.java
+++ b/user/src/com/google/gwt/user/rebind/rpc/FieldSerializerCreator.java
@@ -18,7 +18,6 @@
 import com.google.gwt.core.client.UnsafeNativeLong;
 import com.google.gwt.core.client.impl.WeakMapping;
 import com.google.gwt.core.ext.GeneratorContext;
-import com.google.gwt.core.ext.GeneratorContextExt;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.typeinfo.JArrayType;
 import com.google.gwt.core.ext.typeinfo.JClassType;
@@ -63,7 +62,7 @@
 
   private static final String WEAK_MAPPING_CLASS_NAME = WeakMapping.class.getName();
 
-  private final GeneratorContextExt context;
+  private final GeneratorContext context;
 
   private final JClassType customFieldSerializer;
 
@@ -94,7 +93,7 @@
   /**
    * Constructs a field serializer for the class.
    */
-  public FieldSerializerCreator(GeneratorContextExt context,
+  public FieldSerializerCreator(GeneratorContext context,
       SerializableTypeOracle typesSentFromBrowser, SerializableTypeOracle typesSentToBrowser,
       JClassType requestedClass, JClassType customFieldSerializer) {
     this.context = context;
diff --git a/user/src/com/google/gwt/user/rebind/rpc/ProxyCreator.java b/user/src/com/google/gwt/user/rebind/rpc/ProxyCreator.java
index 0596841..8b037da 100644
--- a/user/src/com/google/gwt/user/rebind/rpc/ProxyCreator.java
+++ b/user/src/com/google/gwt/user/rebind/rpc/ProxyCreator.java
@@ -18,9 +18,13 @@
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.core.client.impl.Impl;
 import com.google.gwt.core.ext.BadPropertyValueException;
+import com.google.gwt.core.ext.CachedPropertyInformation;
+import com.google.gwt.core.ext.CachedGeneratorResult;
 import com.google.gwt.core.ext.ConfigurationProperty;
-import com.google.gwt.core.ext.GeneratorContextExt;
+import com.google.gwt.core.ext.GeneratorContext;
 import com.google.gwt.core.ext.PropertyOracle;
+import com.google.gwt.core.ext.RebindMode;
+import com.google.gwt.core.ext.RebindResult;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.core.ext.linker.EmittedArtifact.Visibility;
@@ -36,11 +40,6 @@
 import com.google.gwt.core.ext.typeinfo.NotFoundException;
 import com.google.gwt.core.ext.typeinfo.TypeOracle;
 import com.google.gwt.dev.generator.NameFactory;
-import com.google.gwt.dev.javac.rebind.CachedClientDataMap;
-import com.google.gwt.dev.javac.rebind.CachedPropertyInformation;
-import com.google.gwt.dev.javac.rebind.CachedRebindResult;
-import com.google.gwt.dev.javac.rebind.RebindResult;
-import com.google.gwt.dev.javac.rebind.RebindStatus;
 import com.google.gwt.dev.util.Util;
 import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
@@ -101,7 +100,7 @@
   public static final String MANIFEST_ARTIFACT_DIR = "rpcPolicyManifest/manifests";
 
   /**
-   * Properties which need to be checked to determine cacheability.
+   * Properties which need to be checked to determine cache reusability.
    */
   private static final Collection<String> configPropsToCheck = Arrays.asList(
       TypeSerializerCreator.GWT_ELIDE_TYPE_NAMES_FROM_RPC, Shared.RPC_ENHANCED_CLASSES);
@@ -254,7 +253,7 @@
    * 
    * @throws UnableToCompleteException
    */
-  public RebindResult create(TreeLogger logger, GeneratorContextExt context)
+  public RebindResult create(TreeLogger logger, GeneratorContext context)
       throws UnableToCompleteException {
     TypeOracle typeOracle = context.getTypeOracle();
 
@@ -268,7 +267,7 @@
     }
 
     if (checkAlreadyGenerated(typeOracle, serviceIntf)) {
-      return new RebindResult(RebindStatus.USE_EXISTING, getProxyQualifiedName());
+      return new RebindResult(RebindMode.USE_EXISTING, getProxyQualifiedName());
     }
 
     // Make sure that the async and synchronous versions of the RemoteService
@@ -328,7 +327,7 @@
     // Check previous cached result, to see if we can return now
     if (checkCachedGeneratorResultValid(logger, context, typesSentFromBrowser, typesSentToBrowser)) {
       logger.log(TreeLogger.TRACE, "Reusing all cached artifacts for " + getProxyQualifiedName());
-      return new RebindResult(RebindStatus.USE_ALL_CACHED, getProxyQualifiedName());
+      return new RebindResult(RebindMode.USE_ALL_CACHED, getProxyQualifiedName());
     }
 
     try {
@@ -347,7 +346,7 @@
     if (srcWriter == null) {
       // don't expect this to occur, but could happen if an instance was
       // recently generated but not yet committed
-      return new RebindResult(RebindStatus.USE_EXISTING, getProxyQualifiedName());
+      return new RebindResult(RebindMode.USE_EXISTING, getProxyQualifiedName());
     }
 
     generateTypeHandlers(logger, context, typesSentFromBrowser, typesSentToBrowser);
@@ -379,25 +378,28 @@
     }
 
     if (checkGeneratorResultCacheability(context)) {
-      // Remember the type info that we care about for cacheability testing.
-      CachedClientDataMap clientData = new CachedClientDataMap();
+      /*
+       * Create a new cacheable result. The mode is set to
+       * RebindMode.USE_PARTIAL_CACHED, since we are allowing reuse of cached
+       * results for field serializers, when available, but all other types have
+       * been newly generated.
+       */
+      RebindResult result =
+          new RebindResult(RebindMode.USE_PARTIAL_CACHED, getProxyQualifiedName());
+
+      // Remember the type info that we care about for cache reuse testing.
       CachedRpcTypeInformation cti =
           new CachedRpcTypeInformation(typesSentFromBrowser, typesSentToBrowser,
               customSerializersUsed, typesNotUsingCustomSerializers);
-      clientData.put(CACHED_TYPE_INFO_KEY, cti);
       CachedPropertyInformation cpi =
           new CachedPropertyInformation(logger, context.getPropertyOracle(), selectionPropsToCheck,
               configPropsToCheck);
-      clientData.put(CACHED_PROPERTY_INFO_KEY, cpi);
+      result.putClientData(CACHED_TYPE_INFO_KEY, cti);
+      result.putClientData(CACHED_PROPERTY_INFO_KEY, cpi);
 
-      /*
-       * Return with RebindStatus.USE_PARTIAL_CACHED, since we are allowing
-       * reuse of cached results for field serializers, when available, but
-       * all other types have been newly generated.
-       */
-      return new RebindResult(RebindStatus.USE_PARTIAL_CACHED, getProxyQualifiedName(), clientData);
+      return result;
     } else {
-      return new RebindResult(RebindStatus.USE_ALL_NEW_WITH_NO_CACHING, getProxyQualifiedName());
+      return new RebindResult(RebindMode.USE_ALL_NEW_WITH_NO_CACHING, getProxyQualifiedName());
     }
   }
 
@@ -689,7 +691,7 @@
     srcWriter.println("}");
   }
 
-  protected void generateTypeHandlers(TreeLogger logger, GeneratorContextExt context,
+  protected void generateTypeHandlers(TreeLogger logger, GeneratorContext context,
       SerializableTypeOracle typesSentFromBrowser, SerializableTypeOracle typesSentToBrowser)
       throws UnableToCompleteException {
     Event event = SpeedTracerLogger.start(CompilerEventType.GENERATOR_RPC_TYPE_SERIALIZER);
@@ -730,7 +732,7 @@
     return ClientSerializationStreamWriter.class;
   }
 
-  protected String writeSerializationPolicyFile(TreeLogger logger, GeneratorContextExt ctx,
+  protected String writeSerializationPolicyFile(TreeLogger logger, GeneratorContext ctx,
       SerializableTypeOracle serializationSto, SerializableTypeOracle deserializationSto)
       throws UnableToCompleteException {
     try {
@@ -832,10 +834,10 @@
     return typeOracle.findType(packageName, getProxySimpleName()) != null;
   }
 
-  private boolean checkCachedGeneratorResultValid(TreeLogger logger, GeneratorContextExt ctx,
+  private boolean checkCachedGeneratorResultValid(TreeLogger logger, GeneratorContext ctx,
       SerializableTypeOracle typesSentFromBrowser, SerializableTypeOracle typesSentToBrowser) {
 
-    CachedRebindResult lastResult = ctx.getCachedGeneratorResult();
+    CachedGeneratorResult lastResult = ctx.getCachedGeneratorResult();
     if (lastResult == null || !ctx.isGeneratorResultCachingEnabled()) {
       return false;
     }
@@ -864,7 +866,7 @@
     return true;
   }
 
-  private boolean checkGeneratorResultCacheability(GeneratorContextExt context) {
+  private boolean checkGeneratorResultCacheability(GeneratorContext context) {
     /*
      * Currently not supporting caching for implementations which sub-class this
      * class, such as {@link RpcProxyCreator}, which implements deRPC.
@@ -876,7 +878,7 @@
     return context.isGeneratorResultCachingEnabled();
   }
 
-  private void emitPolicyFileArtifact(TreeLogger logger, GeneratorContextExt context,
+  private void emitPolicyFileArtifact(TreeLogger logger, GeneratorContext context,
       String partialPath) throws UnableToCompleteException {
     try {
       String qualifiedSourceName = serviceIntf.getQualifiedSourceName();
@@ -924,7 +926,7 @@
     return ResponseReader.OBJECT;
   }
 
-  private SourceWriter getSourceWriter(TreeLogger logger, GeneratorContextExt ctx,
+  private SourceWriter getSourceWriter(TreeLogger logger, GeneratorContext ctx,
       JClassType serviceAsync) {
     JPackage serviceIntfPkg = serviceAsync.getPackage();
     String packageName = serviceIntfPkg == null ? "" : serviceIntfPkg.getName();
diff --git a/user/src/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilder.java b/user/src/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilder.java
index 22437ff..5463c55 100644
--- a/user/src/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilder.java
+++ b/user/src/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilder.java
@@ -15,7 +15,7 @@
  */
 package com.google.gwt.user.rebind.rpc;
 
-import com.google.gwt.core.ext.GeneratorContextExt;
+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;
@@ -307,6 +307,7 @@
    * Compares {@link JType}s according to their qualified source names.
    */
   static final Comparator<JType> JTYPE_COMPARATOR = new Comparator<JType>() {
+    @Override
     public int compare(JType t1, JType t2) {
       return t1.getQualifiedSourceName().compareTo(t2.getQualifiedSourceName());
     }
@@ -316,10 +317,12 @@
    * No type filtering by default..
    */
   private static final TypeFilter DEFAULT_TYPE_FILTER = new TypeFilter() {
+    @Override
     public String getName() {
       return "Default";
     }
 
+    @Override
     public boolean isAllowed(JClassType type) {
       return true;
     }
@@ -726,7 +729,7 @@
    */
   private final JGenericType collectionClass;
 
-  private final GeneratorContextExt context;
+  private final GeneratorContext context;
 
   private Set<String> enhancedClasses = null;
 
@@ -772,13 +775,13 @@
    * 
    * @param logger
    * @param propertyOracle
-   * @param typeOracle
+   * @param context
    * 
    * @throws UnableToCompleteException if we fail to find one of our special
    *           types
    */
   public SerializableTypeOracleBuilder(TreeLogger logger, PropertyOracle propertyOracle,
-      GeneratorContextExt context) throws UnableToCompleteException {
+      GeneratorContext context) throws UnableToCompleteException {
     this.context = context;
     this.typeOracle = context.getTypeOracle();
     typeConstrainer = new TypeConstrainer(typeOracle);
@@ -1329,7 +1332,7 @@
    * Check the argument to a parameterized type to see if it will make the type
    * it is applied to be serializable. As a side effect, populates
    * {@link #typeToTypeInfoComputed} in the same way as
-   * {@link #checkTypeInstantiable(TreeLogger, JType, boolean)}.
+   * {@link #computeTypeInstantiability}.
    * 
    * @param logger
    * @param baseType - The generic type the parameter is on
diff --git a/user/src/com/google/gwt/user/rebind/rpc/ServiceInterfaceProxyGenerator.java b/user/src/com/google/gwt/user/rebind/rpc/ServiceInterfaceProxyGenerator.java
index 60435de..2e9026a 100644
--- a/user/src/com/google/gwt/user/rebind/rpc/ServiceInterfaceProxyGenerator.java
+++ b/user/src/com/google/gwt/user/rebind/rpc/ServiceInterfaceProxyGenerator.java
@@ -15,22 +15,31 @@
  */
 package com.google.gwt.user.rebind.rpc;
 
-import com.google.gwt.core.ext.GeneratorContextExt;
-import com.google.gwt.core.ext.GeneratorExt;
+import com.google.gwt.core.ext.GeneratorContext;
+import com.google.gwt.core.ext.IncrementalGenerator;
+import com.google.gwt.core.ext.RebindResult;
 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.TypeOracle;
-import com.google.gwt.dev.javac.rebind.RebindResult;
 
 /**
  * Generator for producing the asynchronous version of a
  * {@link com.google.gwt.user.client.rpc.RemoteService RemoteService} interface.
  */
-public class ServiceInterfaceProxyGenerator extends GeneratorExt {
+public class ServiceInterfaceProxyGenerator extends IncrementalGenerator {
+
+  /*
+   * A version id. Increment this as needed, when structural changes are made to
+   * the generated output, specifically with respect to it's effect on the
+   * caching and reuse of previous generator results. Previously cached
+   * generator results will be invalidated automatically if they were generated
+   * by a version of this generator with a different version id.
+   */
+  private static final long GENERATOR_VERSION_ID = 1L;
 
   @Override
-  public RebindResult generateIncrementally(TreeLogger logger, GeneratorContextExt ctx,
+  public RebindResult generateIncrementally(TreeLogger logger, GeneratorContext ctx,
       String requestedClass) throws UnableToCompleteException {
 
     TypeOracle typeOracle = ctx.getTypeOracle();
@@ -58,6 +67,11 @@
     return proxyCreator.create(proxyLogger, ctx);
   }
 
+  @Override
+  public long getVersionId() {
+    return GENERATOR_VERSION_ID;
+  }
+
   protected ProxyCreator createProxyCreator(JClassType remoteService) {
     return new ProxyCreator(remoteService);
   }
diff --git a/user/src/com/google/gwt/user/rebind/rpc/TypeSerializerCreator.java b/user/src/com/google/gwt/user/rebind/rpc/TypeSerializerCreator.java
index 7489b7b..753d5f0 100644
--- a/user/src/com/google/gwt/user/rebind/rpc/TypeSerializerCreator.java
+++ b/user/src/com/google/gwt/user/rebind/rpc/TypeSerializerCreator.java
@@ -20,8 +20,9 @@
 import com.google.gwt.core.client.GwtScriptOnly;
 import com.google.gwt.core.client.JsArrayString;
 import com.google.gwt.core.ext.BadPropertyValueException;
+import com.google.gwt.core.ext.CachedGeneratorResult;
 import com.google.gwt.core.ext.ConfigurationProperty;
-import com.google.gwt.core.ext.GeneratorContextExt;
+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;
@@ -29,7 +30,6 @@
 import com.google.gwt.core.ext.typeinfo.JParameterizedType;
 import com.google.gwt.core.ext.typeinfo.JType;
 import com.google.gwt.core.ext.typeinfo.TypeOracle;
-import com.google.gwt.dev.javac.rebind.CachedRebindResult;
 import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event;
@@ -99,7 +99,7 @@
     }
   }
 
-  private final GeneratorContextExt context;
+  private final GeneratorContext context;
 
   private final SerializableTypeOracle deserializationOracle;
 
@@ -124,7 +124,7 @@
   private final Set<JType> customFieldSerializersUsed;
 
   public TypeSerializerCreator(TreeLogger logger, SerializableTypeOracle serializationOracle,
-      SerializableTypeOracle deserializationOracle, GeneratorContextExt context,
+      SerializableTypeOracle deserializationOracle, GeneratorContext context,
       String typeSerializerClassName, String typeSerializerSimpleName)
       throws UnableToCompleteException {
     this.context = context;
@@ -223,7 +223,7 @@
    * Create a field serializer for a type if it does not have a custom
    * serializer.
    */
-  private void createFieldSerializer(TreeLogger logger, GeneratorContextExt ctx, JType type) {
+  private void createFieldSerializer(TreeLogger logger, GeneratorContext ctx, JType type) {
     Event event = SpeedTracerLogger.start(CompilerEventType.GENERATOR_RPC_FIELD_SERIALIZER);
     try {
       assert (type != null);
@@ -249,7 +249,7 @@
           SerializableTypeOracleBuilder.findCustomFieldSerializer(typeOracle, type);
 
       if (ctx.isGeneratorResultCachingEnabled()) {
-        // update cacheable info for next iteration
+        // update cached info for next iteration
         if (customFieldSerializer != null) {
           customFieldSerializersUsed.add(customFieldSerializer);
         } else {
@@ -257,7 +257,7 @@
         }
 
         // check the cache for a valid field serializer for the current type
-        if (findCacheableFieldSerializerAndMarkForReuseIfAvailable(logger, ctx, type,
+        if (findReusableCachedFieldSerializerIfAvailable(logger, ctx, type,
             customFieldSerializer)) {
           // we can skip re-generation of the field serializer for the current
           // type
@@ -278,7 +278,7 @@
   /*
    * Create all of the necessary field serializers.
    */
-  private void createFieldSerializers(TreeLogger logger, GeneratorContextExt ctx) {
+  private void createFieldSerializers(TreeLogger logger, GeneratorContext ctx) {
     JType[] types = getSerializableTypes();
     int typeCount = types.length;
     for (int typeIndex = 0; typeIndex < typeCount; ++typeIndex) {
@@ -294,10 +294,10 @@
    * FieldSerializer. If so, mark it for reuse, and return true. Otherwise
    * return false.
    */
-  private boolean findCacheableFieldSerializerAndMarkForReuseIfAvailable(TreeLogger logger,
-      GeneratorContextExt ctx, JType type, JType customFieldSerializer) {
+  private boolean findReusableCachedFieldSerializerIfAvailable(TreeLogger logger,
+      GeneratorContext ctx, JType type, JType customFieldSerializer) {
 
-    CachedRebindResult lastResult = ctx.getCachedGeneratorResult();
+    CachedGeneratorResult lastResult = ctx.getCachedGeneratorResult();
     if (lastResult == null || !ctx.isGeneratorResultCachingEnabled()) {
       return false;
     }
@@ -330,7 +330,7 @@
             .checkLastModifiedTime(customFieldSerializer)) || (customFieldSerializer == null && cachedTypeInfo
             .checkTypeNotUsingCustomSerializer(type)))) {
       // use cached version, if available
-      foundMatch = ctx.reuseTypeFromCacheIfAvailable(fieldSerializerName);
+      foundMatch = ctx.tryReuseTypeFromCache(fieldSerializerName);
     }
 
     if (logger.isLoggable(TreeLogger.TRACE)) {
@@ -361,7 +361,7 @@
     return serializableTypes;
   }
 
-  private SourceWriter getSourceWriter(TreeLogger logger, GeneratorContextExt ctx) {
+  private SourceWriter getSourceWriter(TreeLogger logger, GeneratorContext ctx) {
     String name[] = getPackageAndClassName(typeSerializerClassName);
     String packageName = name[0];
     String className = name[1];
diff --git a/user/test/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilderTest.java b/user/test/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilderTest.java
index f7dcf56..04a1618 100644
--- a/user/test/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilderTest.java
+++ b/user/test/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilderTest.java
@@ -15,12 +15,9 @@
  */
 package com.google.gwt.user.rebind.rpc;
 
-import com.google.gwt.core.ext.GeneratorContextExt;
-import com.google.gwt.core.ext.PropertyOracle;
+import com.google.gwt.core.ext.StubGeneratorContext;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
-import com.google.gwt.core.ext.linker.Artifact;
-import com.google.gwt.core.ext.linker.GeneratedResource;
 import com.google.gwt.core.ext.typeinfo.JArrayType;
 import com.google.gwt.core.ext.typeinfo.JClassType;
 import com.google.gwt.core.ext.typeinfo.JGenericType;
@@ -38,12 +35,10 @@
 import com.google.gwt.dev.cfg.ModuleDefLoader;
 import com.google.gwt.dev.cfg.StaticPropertyOracle;
 import com.google.gwt.dev.javac.TypeOracleTestingUtils;
-import com.google.gwt.dev.javac.rebind.CachedRebindResult;
 import com.google.gwt.dev.javac.testing.impl.JavaResourceBase;
 import com.google.gwt.dev.javac.testing.impl.MockJavaResource;
 import com.google.gwt.dev.javac.testing.impl.StaticJavaResource;
 import com.google.gwt.dev.resource.Resource;
-import com.google.gwt.dev.resource.ResourceOracle;
 import com.google.gwt.dev.util.log.PrintWriterTreeLogger;
 import com.google.gwt.user.rebind.rpc.testcases.client.AbstractSerializableTypes;
 import com.google.gwt.user.rebind.rpc.testcases.client.ClassWithTypeParameterThatErasesToObject;
@@ -53,7 +48,7 @@
 
 import junit.framework.TestCase;
 
-import java.io.OutputStream;
+// import java.io.OutputStream;
 import java.io.PrintWriter;
 import java.util.Arrays;
 import java.util.Comparator;
@@ -69,68 +64,25 @@
  */
 public class SerializableTypeOracleBuilderTest extends TestCase {
   /**
-   * Just enough of a {@code GeneratorContextExt} to satisfy
+   * Just enough of a {@code GeneratorContext} to satisfy
    * {@code SerializableTypeOracleBuilder}.
    */
-  static class MockContext implements GeneratorContextExt {
+  static class MockContext extends StubGeneratorContext {
     private TypeOracle typeOracle;
 
     MockContext(TypeOracle typeOracle) {
       this.typeOracle = typeOracle;
     }
 
-    public boolean checkRebindRuleAvailable(String sourceTypeName) {
-      return true;
-    }
-
-    public void commit(TreeLogger logger, PrintWriter pw) {
-    }
-
-    public void commitArtifact(TreeLogger logger, Artifact<?> artifact)
-        throws UnableToCompleteException {
-    }
-
-    public GeneratedResource commitResource(TreeLogger logger, OutputStream os)
-        throws UnableToCompleteException {
-      return null;
-    }
-
-    public CachedRebindResult getCachedGeneratorResult() {
-      return null;
-    }
-
-    public PropertyOracle getPropertyOracle() {
-      return null;
-    }
-
-    public ResourceOracle getResourcesOracle() {
-      return null;
-    }
-
+    @Override
     public TypeOracle getTypeOracle() {
       return typeOracle;
     }
 
-    public boolean isGeneratorResultCachingEnabled() {
-      return false;
-    }
-
+    @Override
     public boolean isProdMode() {
       return true;
     }
-
-    public boolean reuseTypeFromCacheIfAvailable(String typeName) {
-      return false;
-    }
-
-    public PrintWriter tryCreate(TreeLogger logger, String packageName, String simpleName) {
-      return null;
-    }
-
-    public OutputStream tryCreateResource(TreeLogger logger, String partialPath)
-        throws UnableToCompleteException {
-      return null;
-    }
   }
 
   /**
@@ -282,6 +234,7 @@
 
   private static void sort(TypeInfo[] typeInfos) {
     Arrays.sort(typeInfos, new Comparator<TypeInfo>() {
+      @Override
       public int compare(TypeInfo ti1, TypeInfo ti2) {
         if (ti1 == ti2) {
           return 0;
@@ -2172,7 +2125,6 @@
   /**
    * Miscellaneous direct tests of {@link TypeConstrainer}.
    * 
-   * @throws UnableToCompleteException
    * @throws NotFoundException
    */
   public void testTypeConstrainer() throws NotFoundException {