diff --git a/dev/core/src/com/google/gwt/dev/AnalyzeModule.java b/dev/core/src/com/google/gwt/dev/AnalyzeModule.java
index 6b7886c..ae1a249 100644
--- a/dev/core/src/com/google/gwt/dev/AnalyzeModule.java
+++ b/dev/core/src/com/google/gwt/dev/AnalyzeModule.java
@@ -1,12 +1,12 @@
 /*
  * 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
@@ -18,11 +18,11 @@
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.CompileTaskRunner.CompileTask;
+import com.google.gwt.dev.Precompile.PrecompileOptions;
 import com.google.gwt.dev.Precompile.PrecompileOptionsImpl;
 import com.google.gwt.dev.cfg.ModuleDef;
 import com.google.gwt.dev.cfg.ModuleDefLoader;
 import com.google.gwt.dev.cfg.PropertyPermutations;
-import com.google.gwt.dev.jjs.JJSOptions;
 import com.google.gwt.dev.util.Memory;
 import com.google.gwt.dev.util.Util;
 import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
@@ -30,6 +30,7 @@
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event;
 
 import java.io.File;
+import java.io.IOException;
 
 /**
  * Performs the first phase of compilation, generating the set of permutations
@@ -37,27 +38,13 @@
  */
 public class AnalyzeModule {
 
-  private interface AnalyzeModuleOptions extends JJSOptions, CompileTaskOptions {
-  }
-
-  static class ArgProcessor extends CompileArgProcessor {
-    public ArgProcessor(AnalyzeModuleOptions options) {
-      super(options);
-    }
-
-    @Override
-    protected String getName() {
-      return AnalyzeModule.class.getName();
-    }
-  }
-
   /**
-   * Mirror all the compiler options, in case this makes some
-   * difference in module analysis.
+   * Mirror all the compiler options, in case this makes some difference in
+   * module analysis.
    */
-  static class AnalyzeModuleOptionsImpl extends PrecompileOptionsImpl
-      implements AnalyzeModuleOptions {
-    private final PrecompileOptionsImpl precompileOptions = new PrecompileOptionsImpl();
+  @SuppressWarnings("serial")
+  static class AnalyzeModuleOptionsImpl extends PrecompileOptionsImpl implements
+      AnalyzeModuleOptions {
 
     public AnalyzeModuleOptionsImpl() {
     }
@@ -68,13 +55,40 @@
 
     public void copyFrom(AnalyzeModuleOptions other) {
       super.copyFrom(other);
-      precompileOptions.copyFrom(other);
     }
   }
 
+  static class ArgProcessor extends Precompile.ArgProcessor {
+    public ArgProcessor(AnalyzeModuleOptions options) {
+      super(options);
+    }
+
+    @Override
+    protected String getName() {
+      return AnalyzeModule.class.getName();
+    }
+  }
+
+  private interface AnalyzeModuleOptions extends Precompile.PrecompileOptions {
+    // This interface is here to support future options.
+  }
+
   /**
-   * Performs a command-line analysis of the module with output to files
-   * for use in further sharded build steps.
+   * The options passed to the AnalyzeModule step are saved here and passed
+   * through to future steps.
+   */
+  static final String OPTIONS_FILENAME = "compilerOptions.ser";
+
+  /**
+   * Count of the maximum number of permutations in the module configuration.
+   * Used to communicate the number of permutations defined in a module to an
+   * external build tool.
+   */
+  static final String PERM_COUNT_FILENAME = "permCount.txt";
+
+  /**
+   * Performs a command-line analysis of the module with output to files for use
+   * in further sharded build steps.
    */
   public static void main(String[] args) {
     Memory.initialize();
@@ -92,6 +106,29 @@
     analyzeModuleEvent.end();
   }
 
+  /**
+   * Loads the AnalyzeModule.OPTIONS_FILENAME data.
+   *
+   * Silently returns <code>null</code> if the file is not found or another problem is
+   * encountered reading the file.
+   */
+  public static PrecompileOptions readAnalyzeModuleOptionsFile(
+      TreeLogger logger, File compilerWorkDir) {
+    File optionsFile = new File(compilerWorkDir, AnalyzeModule.OPTIONS_FILENAME);
+    PrecompileOptions precompilationOptions = null;
+    try {
+      precompilationOptions = Util.readFileAsObject(optionsFile,
+          PrecompileOptions.class);
+    } catch (IOException e) {
+      logger.log(TreeLogger.DEBUG, "Failed to read " + optionsFile
+          + "\nHas AnalyzeModule been run?  Falling back.", e);
+      return null;
+    } catch (ClassNotFoundException e) {
+      logger.log(TreeLogger.ERROR, "Failed to read " + optionsFile, e);
+      return null;
+    }
+    return precompilationOptions;
+  }
 
   private final AnalyzeModuleOptionsImpl options;
 
@@ -100,31 +137,31 @@
   }
 
   public boolean run(TreeLogger logger) throws UnableToCompleteException {
-
     for (String moduleName : options.getModuleNames()) {
       File compilerWorkDir = options.getCompilerWorkDir(moduleName);
       Util.recursiveDelete(compilerWorkDir, true);
       // No need to check mkdirs result because an IOException will occur anyway
       compilerWorkDir.mkdirs();
-     
+
       ModuleDef module = ModuleDefLoader.loadFromClassPath(logger, moduleName);
-      
       logger.log(TreeLogger.INFO, "Analyzing module " + module.getName());
 
       /*
-       * Count the permutations to expose to external build tools performing
-       * a sharded compile.
+       * Count the permutations to expose to external build tools performing a
+       * sharded compile.
        */
-      int numPermutations =
-          new PropertyPermutations(module.getProperties(), module.getActiveLinkerNames())
-              .collapseProperties().size();
-      Util.writeStringAsFile(logger, new File(compilerWorkDir, Precompile.PERM_COUNT_FILENAME),
-          String.valueOf(numPermutations));
-      
-      // TODO(zundel): Serializing the ModuleDef structure would save time in subsequent steps.
-      
-      // TODO(zundel): Building the initial type oracle in this step would save cputime when
-      //               the precompile step is sharded.
+      int numPermutations = new PropertyPermutations(module.getProperties(),
+          module.getActiveLinkerNames()).collapseProperties().size();
+      Util.writeStringAsFile(logger, new File(compilerWorkDir,
+          AnalyzeModule.PERM_COUNT_FILENAME), String.valueOf(numPermutations));
+      Util.writeObjectAsFile(logger, new File(compilerWorkDir,
+          AnalyzeModule.OPTIONS_FILENAME), options);
+
+      // TODO(zundel): Serializing the ModuleDef structure would save time in
+      // subsequent steps.
+
+      // TODO(zundel): Building the initial type oracle in this step would save
+      // cputime when the precompile step is sharded.
     }
 
     return true;
diff --git a/dev/core/src/com/google/gwt/dev/CompileOnePerm.java b/dev/core/src/com/google/gwt/dev/CompileOnePerm.java
new file mode 100644
index 0000000..ddfbddd
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/CompileOnePerm.java
@@ -0,0 +1,190 @@
+/*
+ * 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;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.CompileTaskRunner.CompileTask;
+import com.google.gwt.dev.Precompile.PrecompileOptions;
+import com.google.gwt.dev.cfg.ModuleDef;
+import com.google.gwt.dev.cfg.ModuleDefLoader;
+import com.google.gwt.dev.jjs.PermutationResult;
+import com.google.gwt.dev.util.PerfCounter;
+import com.google.gwt.dev.util.arg.ArgHandlerPerm;
+import com.google.gwt.dev.util.arg.OptionPerm;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * Performs the second phase of compilation, converting one of the Precompile's
+ * serialized AST files into JavaScript outputs.
+ */
+public class CompileOnePerm {
+
+  /**
+   * Options for CompilePerm.
+   */
+  public interface CompileOnePermOptions extends CompileTaskOptions, OptionPerm {
+  }
+
+  static class ArgProcessor extends CompileArgProcessor {
+    public ArgProcessor(CompileOnePermOptions options) {
+      super(options);
+      registerHandler(new ArgHandlerPerm(options));
+    }
+
+    @Override
+    protected String getName() {
+      return CompileOnePerm.class.getName();
+    }
+  }
+
+  /**
+   * Concrete class to implement compiler perm options.
+   */
+  static class CompileOnePermOptionsImpl extends CompileTaskOptionsImpl
+      implements CompileOnePermOptions {
+
+    private int permToCompile = -1;
+
+    public CompileOnePermOptionsImpl() {
+    }
+
+    public CompileOnePermOptionsImpl(CompileOnePermOptions other) {
+      copyFrom(other);
+    }
+
+    public void copyFrom(CompileOnePermOptions other) {
+      super.copyFrom(other);
+      setPermToCompile(other.getPermToCompile());
+    }
+
+    public int getPermToCompile() {
+      return permToCompile;
+    }
+
+    public void setPermToCompile(int permToCompile) {
+      this.permToCompile = permToCompile;
+    }
+  }
+
+  public static void main(String[] args) {
+    int exitCode = -1;
+    /*
+     * NOTE: main always exits with a call to System.exit to terminate any
+     * non-daemon threads that were started in Generators. Typically, this is to
+     * shutdown AWT related threads, since the contract for their termination is
+     * still implementation-dependent.
+     */
+    final CompileOnePermOptions options = new CompileOnePermOptionsImpl();
+    if (new ArgProcessor(options).processArgs(args)) {
+      CompileTask task = new CompileTask() {
+        public boolean run(TreeLogger logger) throws UnableToCompleteException {
+          return new CompileOnePerm(options).run(logger);
+        }
+      };
+      if (CompileTaskRunner.runWithAppropriateLogger(options, task)) {
+        // Exit w/ success code.
+        exitCode = 0;
+      }
+    }
+    PerfCounter.print();
+    System.exit(exitCode);
+  }
+
+  /**
+   * Return the filename corresponding to the given permutation number,
+   * one-based.
+   */
+  static File makePermFilename(File compilerWorkDir, int permNumber) {
+    return new File(compilerWorkDir, "permutation-" + permNumber + ".js");
+  }
+
+  /**
+   * Run Compile where precompilation occurred previously on sharded steps of
+   * Precompile. There will be a different serialized AST file named
+   * permutation-*.ser, one per permutation.
+   *
+   * @param logger tree logger
+   * @param moduleName Name of the GWT module with the entry point
+   * @param permId permutations to compile
+   * @param compilerWorkDir directory where work files are stored
+   *
+   * @return <code>true</code> if compilation succeeds
+   */
+  private static boolean compileSpecificPermutation(TreeLogger logger,
+      String moduleName, PrecompileOptions precompilationOptions, int permId,
+      File compilerWorkDir) throws UnableToCompleteException {
+
+    ModuleDef module = ModuleDefLoader.loadFromClassPath(logger, moduleName);
+
+    logger = logger.branch(TreeLogger.INFO, "Compiling permutation " + permId);
+
+    File precompilationFile = new File(compilerWorkDir,
+        PrecompileOnePerm.getPrecompileFilename(permId));
+    Precompilation precompilation = (Precompilation) CompilePerms.readPrecompilationFile(
+        logger, precompilationFile);
+
+    // Choose the permutation that goes with this precompilation
+    Permutation[] subPerms = CompilePerms.selectPermutationsForPrecompilation(
+        new int[]{permId}, precompilation);
+    assert subPerms.length == 1;
+
+    PermutationResult permResult = precompilation.getUnifiedAst().compilePermutation(
+        logger, subPerms[0]);
+    Link.linkOnePermutationToJar(logger, module,
+        precompilation.getGeneratedArtifacts(), permResult, makePermFilename(
+            compilerWorkDir, permId), precompilationOptions);
+    return true;
+  }
+
+  private final CompileOnePermOptionsImpl options;
+
+  public CompileOnePerm(CompileOnePermOptions options) {
+    this.options = new CompileOnePermOptionsImpl(options);
+  }
+
+  public boolean run(TreeLogger logger) throws UnableToCompleteException {
+    List<String> moduleNames = options.getModuleNames();
+    if (moduleNames.size() != 1) {
+      logger.log(TreeLogger.ERROR, "Expected a single module name.");
+      return false;
+    }
+    int permToRun = options.getPermToCompile();
+    if (permToRun < 0) {
+      logger.log(TreeLogger.ERROR,
+          "Expected argument -perm to specify the permutation to compile.");
+      return false;
+    }
+
+    String moduleName = moduleNames.get(0);
+    File compilerWorkDir = options.getCompilerWorkDir(moduleName);
+
+    // Look for the sentinel file that indicates that this compilation already
+    // has a precompilation result from a previous Precompile step.
+    PrecompileOptions precompilationOptions = AnalyzeModule.readAnalyzeModuleOptionsFile(
+        logger, compilerWorkDir);
+    if (precompilationOptions == null) {
+      logger.log(TreeLogger.ERROR, "Could not read file "
+          + AnalyzeModule.OPTIONS_FILENAME + " output from AnalyzeModule step.");
+      return false;
+    }
+
+    return compileSpecificPermutation(logger, moduleName,
+        precompilationOptions, permToRun, compilerWorkDir);
+  }
+}
diff --git a/dev/core/src/com/google/gwt/dev/CompilePerms.java b/dev/core/src/com/google/gwt/dev/CompilePerms.java
index d1a7fa2..176bad1 100644
--- a/dev/core/src/com/google/gwt/dev/CompilePerms.java
+++ b/dev/core/src/com/google/gwt/dev/CompilePerms.java
@@ -250,11 +250,27 @@
     return new File(compilerWorkDir, "permutation-" + permNumber + ".js");
   }
 
+  static PrecompilationResult readPrecompilationFile(TreeLogger logger,
+      File precompilationFile) {
+    PrecompilationResult precompileResults = null;
+    try {
+      precompileResults = Util.readFileAsObject(precompilationFile,
+          PrecompilationResult.class);
+    } catch (IOException e) {
+      logger.log(TreeLogger.ERROR, "Failed to read "
+          + precompilationFile + "\nHas Precompile been run?");
+    } catch (ClassNotFoundException e) {
+      logger.log(TreeLogger.ERROR, "Failed to read "
+          + precompilationFile, e);
+    }
+    return precompileResults;
+  }
+
   /**
    * Choose the subset of requested permutations that correspond to the
    * indicated precompilation.
    */
-  private static Permutation[] selectPermutationsForPrecompilation(
+  static Permutation[] selectPermutationsForPrecompilation(
       int[] permsToRun, Precompilation precompilation) {
     if (permsToRun == null) {
       // Special case: compile everything.
@@ -288,19 +304,8 @@
       File precompilationFile = new File(compilerWorkDir,
           Precompile.PRECOMPILE_FILENAME);
 
-      PrecompilationResult precompileResults;
-      try {
-        precompileResults = Util.readFileAsObject(precompilationFile,
-            PrecompilationResult.class);
-      } catch (IOException e) {
-        logger.log(TreeLogger.ERROR, "Failed to read "
-            + Precompile.PRECOMPILE_FILENAME + "; has Precompile been run?");
-        return false;
-      } catch (ClassNotFoundException e) {
-        logger.log(TreeLogger.ERROR, "Failed to read "
-            + Precompile.PRECOMPILE_FILENAME, e);
-        return false;
-      }
+      PrecompilationResult precompileResults = readPrecompilationFile(logger, 
+          precompilationFile);
 
       if (precompileResults instanceof PrecompileOptions) {
         PrecompileOptions precompilationOptions = (PrecompileOptions) precompileResults;
diff --git a/dev/core/src/com/google/gwt/dev/DistillerRebindPermutationOracle.java b/dev/core/src/com/google/gwt/dev/DistillerRebindPermutationOracle.java
new file mode 100644
index 0000000..babb988
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/DistillerRebindPermutationOracle.java
@@ -0,0 +1,124 @@
+/*
+ * 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;
+
+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.cfg.BindingProperty;
+import com.google.gwt.dev.cfg.ConfigurationProperty;
+import com.google.gwt.dev.cfg.ModuleDef;
+import com.google.gwt.dev.cfg.PropertyPermutations;
+import com.google.gwt.dev.cfg.Rules;
+import com.google.gwt.dev.cfg.StaticPropertyOracle;
+import com.google.gwt.dev.javac.CompilationState;
+import com.google.gwt.dev.javac.StandardGeneratorContext;
+import com.google.gwt.dev.jdt.RebindOracle;
+import com.google.gwt.dev.jdt.RebindPermutationOracle;
+import com.google.gwt.dev.shell.StandardRebindOracle;
+import com.google.gwt.dev.util.Util;
+import com.google.gwt.dev.util.collect.HashSet;
+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;
+
+import java.io.File;
+import java.util.Set;
+import java.util.SortedSet;
+
+/**
+ * Implementation of RebindPermutationOracle used by Precompile.
+ */
+class DistillerRebindPermutationOracle implements RebindPermutationOracle {
+  private CompilationState compilationState;
+  private StandardGeneratorContext generatorContext;
+  private final Permutation[] permutations;
+  private final StaticPropertyOracle[] propertyOracles;
+  private final RebindOracle[] rebindOracles;
+
+  public DistillerRebindPermutationOracle(ModuleDef module,
+      CompilationState compilationState, ArtifactSet generatorArtifacts,
+      PropertyPermutations perms, File genDir) {
+    this.compilationState = compilationState;
+    permutations = new Permutation[perms.size()];
+    propertyOracles = new StaticPropertyOracle[perms.size()];
+    rebindOracles = new RebindOracle[perms.size()];
+    generatorContext = new StandardGeneratorContext(compilationState, module,
+        genDir, generatorArtifacts);
+    BindingProperty[] orderedProps = perms.getOrderedProperties();
+    SortedSet<ConfigurationProperty> configPropSet = module.getProperties().getConfigurationProperties();
+    ConfigurationProperty[] configProps = configPropSet.toArray(new ConfigurationProperty[configPropSet.size()]);
+    Rules rules = module.getRules();
+    for (int i = 0; i < rebindOracles.length; ++i) {
+      String[] orderedPropValues = perms.getOrderedPropertyValues(i);
+      propertyOracles[i] = new StaticPropertyOracle(orderedProps,
+          orderedPropValues, configProps);
+      rebindOracles[i] = new StandardRebindOracle(propertyOracles[i], rules,
+          generatorContext);
+      permutations[i] = new Permutation(i, propertyOracles[i]);
+    }
+  }
+
+  public void clear() {
+    generatorContext.clear();
+    compilationState = null;
+    generatorContext = null;
+  }
+
+  public String[] getAllPossibleRebindAnswers(TreeLogger logger,
+      String requestTypeName) throws UnableToCompleteException {
+
+    String msg = "Computing all possible rebind results for '"
+        + requestTypeName + "'";
+    logger = logger.branch(TreeLogger.DEBUG, msg, null);
+
+    Set<String> answers = new HashSet<String>();
+    Event getAllRebindsEvent = SpeedTracerLogger.start(CompilerEventType.GET_ALL_REBINDS);
+    for (int i = 0; i < getPermuationCount(); ++i) {
+      String resultTypeName = rebindOracles[i].rebind(logger, requestTypeName);
+      answers.add(resultTypeName);
+      // Record the correct answer into each permutation.
+      permutations[i].putRebindAnswer(requestTypeName, resultTypeName);
+    }
+    String[] result = Util.toArray(String.class, answers);
+    getAllRebindsEvent.end();
+    return result;
+  }
+
+  public CompilationState getCompilationState() {
+    return compilationState;
+  }
+
+  public StandardGeneratorContext getGeneratorContext() {
+    return generatorContext;
+  }
+
+  public int getPermuationCount() {
+    return rebindOracles.length;
+  }
+
+  public Permutation[] getPermutations() {
+    return permutations;
+  }
+
+  public StaticPropertyOracle getPropertyOracle(int permNumber) {
+    return propertyOracles[permNumber];
+  }
+
+  public RebindOracle getRebindOracle(int permNumber) {
+    return rebindOracles[permNumber];
+  }
+}
diff --git a/dev/core/src/com/google/gwt/dev/Link.java b/dev/core/src/com/google/gwt/dev/Link.java
index 9c46fc3..261f522 100644
--- a/dev/core/src/com/google/gwt/dev/Link.java
+++ b/dev/core/src/com/google/gwt/dev/Link.java
@@ -67,6 +67,7 @@
 import java.util.jar.JarFile;
 import java.util.jar.JarOutputStream;
 import java.util.zip.ZipEntry;
+import java.util.zip.ZipException;
 
 /**
  * Performs the last phase of compilation, merging the compilation outputs.
@@ -199,8 +200,7 @@
     if (deployDir.equals(extrasDir)) {
       deployFileSet = extrasFileSet;
     } else {
-      deployFileSet = chooseOutputFileSet(deployDir,
-          module.getName() + "/");
+      deployFileSet = chooseOutputFileSet(deployDir, module.getName() + "/");
     }
     doProduceOutput(logger, artifacts, linkerContext, chooseOutputFileSet(
         outDir, module.getName() + "/"), deployFileSet, extrasFileSet);
@@ -220,7 +220,7 @@
       if (jarFile.exists()) {
         boolean success = jarFile.delete();
         if (!success) {
-          logger.log(Type.ERROR, "Linker output file " + jarFile.getName() 
+          logger.log(Type.ERROR, "Linker output file " + jarFile.getName()
               + " already exists and can't be deleted.");
         }
       }
@@ -523,8 +523,8 @@
    * @param linkerContext
    * @return prefixed path
    */
-  private static String prefixArtifactPath(
-      EmittedArtifact art, StandardLinkerContext linkerContext) {
+  private static String prefixArtifactPath(EmittedArtifact art,
+      StandardLinkerContext linkerContext) {
     String pathWithLinkerName = linkerContext.getExtraPathForLinker(
         art.getLinker(), art.getPartialPath());
     if (pathWithLinkerName.startsWith("/")) {
@@ -539,7 +539,15 @@
     final ArtifactSet artifacts = new ArtifactSet();
 
     for (File resultFile : resultFiles) {
-      JarFile jarFile = new JarFile(resultFile);
+      JarFile jarFile = null;
+      try {
+        jarFile = new JarFile(resultFile);
+      } catch (ZipException ze) {
+        logger.log(TreeLogger.ERROR, "Error opening " + resultFile
+            + " as jar file.", ze);
+        throw new UnableToCompleteException();
+      }
+
       Enumeration<JarEntry> entries = jarFile.entries();
       while (entries.hasMoreElements()) {
         JarEntry entry = entries.nextElement();
@@ -599,26 +607,32 @@
       ModuleDef module = ModuleDefLoader.loadFromClassPath(logger, moduleName);
 
       File compilerWorkDir = options.getCompilerWorkDir(moduleName);
-      PrecompilationResult precompileResults;
-      try {
-        precompileResults = Util.readFileAsObject(new File(compilerWorkDir,
-            Precompile.PRECOMPILE_FILENAME), PrecompilationResult.class);
-      } catch (ClassNotFoundException e) {
-        logger.log(TreeLogger.ERROR, "Error reading "
-            + Precompile.PRECOMPILE_FILENAME);
-        return false;
-      } catch (IOException e) {
-        logger.log(TreeLogger.ERROR, "Error reading "
-            + Precompile.PRECOMPILE_FILENAME);
-        return false;
+
+      // Look for the compilerOptions file output from running AnalyzeModule
+      PrecompileOptions precompileOptions = AnalyzeModule.readAnalyzeModuleOptionsFile(
+          logger, compilerWorkDir);
+
+      PrecompilationResult precompileResults = null;
+      if (precompileOptions == null) {
+        // Check for the output from Precompile where precompiling has
+        // been delegated to shards.
+        File precompilationFile = new File(compilerWorkDir,
+            Precompile.PRECOMPILE_FILENAME);
+        precompileResults = CompilePerms.readPrecompilationFile(logger,
+            precompilationFile);
+        if (precompileResults == null) {
+          return false;
+        }
+        if (precompileResults instanceof PrecompileOptions) {
+          precompileOptions = (PrecompileOptions) precompileResults;
+        }
       }
 
-      if (precompileResults instanceof PrecompileOptions) {
+      if (precompileOptions != null) {
         /**
          * Precompiling happened on the shards.
          */
-        if (!doLinkFinal(logger, compilerWorkDir, module,
-            (JJSOptions) precompileResults)) {
+        if (!doLinkFinal(logger, compilerWorkDir, module, precompileOptions)) {
           return false;
         }
         continue loop_modules;
diff --git a/dev/core/src/com/google/gwt/dev/Precompile.java b/dev/core/src/com/google/gwt/dev/Precompile.java
index 52b1ea3..830e240 100644
--- a/dev/core/src/com/google/gwt/dev/Precompile.java
+++ b/dev/core/src/com/google/gwt/dev/Precompile.java
@@ -24,18 +24,12 @@
 import com.google.gwt.core.ext.linker.impl.StandardLinkerContext;
 import com.google.gwt.core.ext.typeinfo.JClassType;
 import com.google.gwt.dev.CompileTaskRunner.CompileTask;
-import com.google.gwt.dev.cfg.BindingProperty;
 import com.google.gwt.dev.cfg.ConfigurationProperty;
 import com.google.gwt.dev.cfg.ModuleDef;
 import com.google.gwt.dev.cfg.ModuleDefLoader;
 import com.google.gwt.dev.cfg.PropertyPermutations;
-import com.google.gwt.dev.cfg.Rules;
-import com.google.gwt.dev.cfg.StaticPropertyOracle;
 import com.google.gwt.dev.javac.CompilationState;
 import com.google.gwt.dev.javac.CompilationUnit;
-import com.google.gwt.dev.javac.StandardGeneratorContext;
-import com.google.gwt.dev.jdt.RebindOracle;
-import com.google.gwt.dev.jdt.RebindPermutationOracle;
 import com.google.gwt.dev.jjs.AbstractCompiler;
 import com.google.gwt.dev.jjs.JJSOptions;
 import com.google.gwt.dev.jjs.JJSOptionsImpl;
@@ -44,7 +38,6 @@
 import com.google.gwt.dev.jjs.UnifiedAst;
 import com.google.gwt.dev.shell.CheckForUpdates;
 import com.google.gwt.dev.shell.CheckForUpdates.UpdateResult;
-import com.google.gwt.dev.shell.StandardRebindOracle;
 import com.google.gwt.dev.util.CollapsedPropertyKey;
 import com.google.gwt.dev.util.Memory;
 import com.google.gwt.dev.util.Util;
@@ -72,7 +65,6 @@
 import com.google.gwt.dev.util.arg.OptionGenDir;
 import com.google.gwt.dev.util.arg.OptionMaxPermsPerPrecompile;
 import com.google.gwt.dev.util.arg.OptionValidateOnly;
-import com.google.gwt.dev.util.collect.HashSet;
 import com.google.gwt.dev.util.collect.Lists;
 import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
@@ -88,7 +80,6 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.SortedMap;
 import java.util.SortedSet;
 import java.util.TreeMap;
@@ -308,89 +299,6 @@
     }
   }
 
-  private static class DistillerRebindPermutationOracle implements
-      RebindPermutationOracle {
-
-    private CompilationState compilationState;
-    private StandardGeneratorContext generatorContext;
-    private final Permutation[] permutations;
-    private final StaticPropertyOracle[] propertyOracles;
-    private final RebindOracle[] rebindOracles;
-
-    public DistillerRebindPermutationOracle(ModuleDef module,
-        CompilationState compilationState, ArtifactSet generatorArtifacts,
-        PropertyPermutations perms, File genDir) {
-      this.compilationState = compilationState;
-      permutations = new Permutation[perms.size()];
-      propertyOracles = new StaticPropertyOracle[perms.size()];
-      rebindOracles = new RebindOracle[perms.size()];
-      generatorContext = new StandardGeneratorContext(compilationState, module,
-          genDir, generatorArtifacts);
-      BindingProperty[] orderedProps = perms.getOrderedProperties();
-      SortedSet<ConfigurationProperty> configPropSet = module.getProperties().getConfigurationProperties();
-      ConfigurationProperty[] configProps = configPropSet.toArray(new ConfigurationProperty[configPropSet.size()]);
-      Rules rules = module.getRules();
-      for (int i = 0; i < rebindOracles.length; ++i) {
-        String[] orderedPropValues = perms.getOrderedPropertyValues(i);
-        propertyOracles[i] = new StaticPropertyOracle(orderedProps,
-            orderedPropValues, configProps);
-        rebindOracles[i] = new StandardRebindOracle(propertyOracles[i], rules,
-            generatorContext);
-        permutations[i] = new Permutation(i, propertyOracles[i]);
-      }
-    }
-
-    public void clear() {
-      generatorContext.clear();
-      compilationState = null;
-      generatorContext = null;
-    }
-
-    public String[] getAllPossibleRebindAnswers(TreeLogger logger,
-        String requestTypeName) throws UnableToCompleteException {
-
-      String msg = "Computing all possible rebind results for '"
-          + requestTypeName + "'";
-      logger = logger.branch(TreeLogger.DEBUG, msg, null);
-
-      Set<String> answers = new HashSet<String>();
-      Event getAllRebindsEvent = SpeedTracerLogger.start(CompilerEventType.GET_ALL_REBINDS);
-      for (int i = 0; i < getPermuationCount(); ++i) {
-        String resultTypeName = rebindOracles[i].rebind(logger, requestTypeName);
-        answers.add(resultTypeName);
-        // Record the correct answer into each permutation.
-        permutations[i].putRebindAnswer(requestTypeName, resultTypeName);
-      }
-      String[] result = Util.toArray(String.class, answers);
-      getAllRebindsEvent.end();
-      return result;
-    }
-
-    public CompilationState getCompilationState() {
-      return compilationState;
-    }
-
-    public StandardGeneratorContext getGeneratorContext() {
-      return generatorContext;
-    }
-
-    public int getPermuationCount() {
-      return rebindOracles.length;
-    }
-
-    public Permutation[] getPermutations() {
-      return permutations;
-    }
-
-    public StaticPropertyOracle getPropertyOracle(int permNumber) {
-      return propertyOracles[permNumber];
-    }
-
-    public RebindOracle getRebindOracle(int permNumber) {
-      return rebindOracles[permNumber];
-    }
-  }
-
   /**
    * Creates a Graphics2D context in a thread in order to go ahead and get first
    * time initialization out of the way. Delays ranging from 200ms to 6s have
@@ -413,12 +321,23 @@
   };
 
   /**
-   * The file name for the result of Precompile.
+   * The file name for the max number of permutations output as plain text.
    */
-  public static final String PRECOMPILE_FILENAME = "precompilation.ser";
-
   static final String PERM_COUNT_FILENAME = "permCount.txt";
 
+  static final String PRECOMPILE_FILENAME = Precompile.PRECOMPILE_FILENAME_PREFIX
+      + Precompile.PRECOMPILE_FILENAME_SUFFIX;
+
+  /**
+   * The file name for the serialized AST artifact from the Precompile step.
+   * Sometimes this file is overloaded and only contains a PrecompileOptions
+   * object to indicate that precompilation should run inside the CompilePerms
+   * step.
+   */
+  static final String PRECOMPILE_FILENAME_PREFIX = "precompilation";
+
+  static final String PRECOMPILE_FILENAME_SUFFIX = ".ser";
+
   /**
    * Performs a command-line precompile.
    */
@@ -486,7 +405,7 @@
    * @param logger a logger to use
    * @param jjsOptions a set of compiler options
    * @param module the module to compile
-   * @param genDir optional directory to dump generated source, may be 
+   * @param genDir optional directory to dump generated source, may be
    *               <code>null</code>
    */
   public static boolean validate(TreeLogger logger, JJSOptions jjsOptions,
@@ -529,6 +448,39 @@
     }
   }
 
+  /**
+   * Create a list of all possible permutations configured for this module after
+   * collapsing soft permutations.
+   */
+  static List<PropertyPermutations> getCollapsedPermutations(ModuleDef module) {
+    PropertyPermutations allPermutations = new PropertyPermutations(
+        module.getProperties(), module.getActiveLinkerNames());
+    List<PropertyPermutations> collapsedPermutations = allPermutations.collapseProperties();
+    return collapsedPermutations;
+  }
+
+  static AbstractCompiler getCompiler(ModuleDef module) {
+    ConfigurationProperty compilerClassProp = module.getProperties().createConfiguration(
+        "x.compiler.class", false);
+    String compilerClassName = compilerClassProp.getValue();
+    if (compilerClassName == null || compilerClassName.length() == 0) {
+      return new JavaScriptCompiler();
+    }
+    Throwable caught;
+    try {
+      Class<?> compilerClass = Class.forName(compilerClassName);
+      return (AbstractCompiler) compilerClass.newInstance();
+    } catch (ClassNotFoundException e) {
+      caught = e;
+    } catch (InstantiationException e) {
+      caught = e;
+    } catch (IllegalAccessException e) {
+      caught = e;
+    }
+    throw new RuntimeException("Unable to instantiate compiler class '"
+        + compilerClassName + "'", caught);
+  }
+
   static Precompilation precompile(TreeLogger logger, JJSOptions jjsOptions,
       ModuleDef module, int permutationBase,
       PropertyPermutations allPermutations, File genDir) {
@@ -623,7 +575,7 @@
         precompilationMetrics.setPermuationIds(ids);
         // TODO(zundel): Right now this double counts module load and
         // precompile time. It correctly counts the amount of time spent
-        // in this process.  The elapsed time in ModuleMetricsArtifact
+        // in this process. The elapsed time in ModuleMetricsArtifact
         // represents time which could be done once for all permutations.
         precompilationMetrics.setElapsedMilliseconds(System.currentTimeMillis()
             - startTimeMilliseconds);
@@ -646,29 +598,6 @@
         "Aborting compile due to errors in some input files");
     throw new UnableToCompleteException();
   }
-
-  private static AbstractCompiler getCompiler(ModuleDef module) {
-    ConfigurationProperty compilerClassProp = module.getProperties().createConfiguration(
-        "x.compiler.class", false);
-    String compilerClassName = compilerClassProp.getValue();
-    if (compilerClassName == null || compilerClassName.length() == 0) {
-      return new JavaScriptCompiler();
-    }
-    Throwable caught;
-    try {
-      Class<?> compilerClass = Class.forName(compilerClassName);
-      return (AbstractCompiler) compilerClass.newInstance();
-    } catch (ClassNotFoundException e) {
-      caught = e;
-    } catch (InstantiationException e) {
-      caught = e;
-    } catch (IllegalAccessException e) {
-      caught = e;
-    }
-    throw new RuntimeException("Unable to instantiate compiler class '"
-        + compilerClassName + "'", caught);
-  }
-
   /**
    * This merges Permutations that can be considered equivalent by considering
    * their collapsed properties. The list passed into this method may have
@@ -716,7 +645,6 @@
       permutations.set(i, new Permutation(i, permutations.get(i)));
     }
   }
-
   private final PrecompileOptionsImpl options;
 
   public Precompile(PrecompileOptions options) {
@@ -731,7 +659,8 @@
     for (String moduleName : options.getModuleNames()) {
       File compilerWorkDir = options.getCompilerWorkDir(moduleName);
       Util.recursiveDelete(compilerWorkDir, true);
-      // No need to check mkdirs result because an IOException will occur anyway.
+      // No need to check mkdirs result because an IOException will occur
+      // anyway.
       compilerWorkDir.mkdirs();
 
       File precompilationFile = new File(compilerWorkDir, PRECOMPILE_FILENAME);
diff --git a/dev/core/src/com/google/gwt/dev/PrecompileOnePerm.java b/dev/core/src/com/google/gwt/dev/PrecompileOnePerm.java
new file mode 100644
index 0000000..f02a115
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/PrecompileOnePerm.java
@@ -0,0 +1,255 @@
+/*
+ * 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;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.linker.impl.StandardLinkerContext;
+import com.google.gwt.dev.CompileTaskRunner.CompileTask;
+import com.google.gwt.dev.cfg.ModuleDef;
+import com.google.gwt.dev.cfg.ModuleDefLoader;
+import com.google.gwt.dev.cfg.PropertyPermutations;
+import com.google.gwt.dev.shell.CheckForUpdates;
+import com.google.gwt.dev.shell.CheckForUpdates.UpdateResult;
+import com.google.gwt.dev.util.Memory;
+import com.google.gwt.dev.util.Util;
+import com.google.gwt.dev.util.arg.ArgHandlerPerm;
+import com.google.gwt.dev.util.arg.OptionPerm;
+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;
+
+import java.io.File;
+import java.util.List;
+import java.util.concurrent.FutureTask;
+
+/**
+ * Creates a ready-to-compile AST for a single permutation.
+ *
+ * Also collapses similar permutations and builds them together.
+ */
+public class PrecompileOnePerm {
+
+  /**
+   * The set of options for the precompiler.
+   */
+  public interface PrecompileOnePermOptions extends
+      Precompile.PrecompileOptions, OptionPerm {
+  }
+
+  static class ArgProcessor extends Precompile.ArgProcessor {
+    public ArgProcessor(PrecompileOnePermOptions options) {
+      super(options);
+      registerHandler(new ArgHandlerPerm(options));
+    }
+
+    @Override
+    protected String getName() {
+      return PrecompileOnePerm.class.getName();
+    }
+  }
+
+  @SuppressWarnings("serial")
+  static class PrecompileOnePermOptionsImpl extends
+      Precompile.PrecompileOptionsImpl implements PrecompileOnePermOptions {
+
+    int permToCompile = -1;
+
+    public PrecompileOnePermOptionsImpl() {
+    }
+
+    public PrecompileOnePermOptionsImpl(PrecompileOnePermOptions other) {
+      copyFrom(other);
+    }
+
+    public void copyFrom(PrecompileOnePermOptions other) {
+      super.copyFrom(other);
+      setPermToCompile(other.getPermToCompile());
+    }
+
+    public int getPermToCompile() {
+      return permToCompile;
+    }
+
+    public void setPermToCompile(int permToCompile) {
+      this.permToCompile = permToCompile;
+    }
+  }
+
+  /**
+   * Performs a command-line precompile.
+   */
+  public static void main(String[] args) {
+    Memory.initialize();
+    SpeedTracerLogger.init();
+    Event precompileEvent = SpeedTracerLogger.start(CompilerEventType.PRECOMPILE);
+    if (System.getProperty("gwt.jjs.dumpAst") != null) {
+      System.out.println("Will dump AST to: "
+          + System.getProperty("gwt.jjs.dumpAst"));
+    }
+
+    /*
+     * NOTE: main always exits with a call to System.exit to terminate any
+     * non-daemon threads that were started in Generators. Typically, this is to
+     * shutdown AWT related threads, since the contract for their termination is
+     * still implementation-dependent.
+     */
+    final PrecompileOnePermOptions options = new PrecompileOnePermOptionsImpl();
+    boolean success = false;
+    if (new ArgProcessor(options).processArgs(args)) {
+      CompileTask task = new CompileTask() {
+        public boolean run(TreeLogger logger) throws UnableToCompleteException {
+          FutureTask<UpdateResult> updater = null;
+          if (!options.isUpdateCheckDisabled()) {
+            updater = CheckForUpdates.checkForUpdatesInBackgroundThread(logger,
+                CheckForUpdates.ONE_DAY);
+          }
+          boolean success = new PrecompileOnePerm(options).run(logger);
+          if (success) {
+            CheckForUpdates.logUpdateAvailable(logger, updater);
+          }
+          return success;
+        }
+      };
+      if (CompileTaskRunner.runWithAppropriateLogger(options, task)) {
+        // Exit w/ success code.
+        success = true;
+      }
+    }
+    precompileEvent.end();
+    System.exit(success ? 0 : 1);
+  }
+
+  /**
+   * Returns a filename for the serialized AST when precompile is performed
+   * separately on a per-permutation basis.
+   */
+  static String getPrecompileFilename(int permutationBase) {
+    return Precompile.PRECOMPILE_FILENAME_PREFIX + "-" + permutationBase
+        + Precompile.PRECOMPILE_FILENAME_SUFFIX;
+  }
+
+  private static boolean validateOptions(TreeLogger logger, PrecompileOnePermOptions options) {
+    // Fatal Errors
+    if (options.getModuleNames().size() != 1) {
+      logger.log(TreeLogger.ERROR, "Expected a single module name.");
+      return false;
+    }
+    if (options.getPermToCompile() < 0) {
+      logger.log(TreeLogger.ERROR,
+          "Expected argument -perm to specify the permutation to compile.");
+      return false;
+    }
+
+    // Warnings
+    if (!options.isEnabledGeneratingOnShards()) {
+      logger.log(TreeLogger.WARN,
+      "-XdisableGeneratingOnShards has no effect in PrecompileOnePerm");
+    }
+    if (options.getMaxPermsPerPrecompile() != -1) {
+      logger.log(TreeLogger.WARN,
+      "-XmaxPermsPerPrecompile has no effect in PrecompileOnePerm");
+    }
+
+    return true;
+  }
+
+  private final PrecompileOnePermOptionsImpl options;
+
+  public PrecompileOnePerm(PrecompileOnePermOptions options) {
+    this.options = new PrecompileOnePermOptionsImpl(options);
+  }
+
+  public boolean run(TreeLogger logger) throws UnableToCompleteException {
+
+    if (!validateOptions(logger, options)) {
+      return false;
+    }
+
+    // Avoid early optimizations since permutation compiles will run separately.
+    options.setOptimizePrecompile(false);
+
+    List<String> moduleNames = options.getModuleNames();
+
+    int permToRun = options.getPermToCompile();
+
+    String moduleName = moduleNames.get(0);
+    File compilerWorkDir = options.getCompilerWorkDir(moduleName);
+
+    ModuleDef module = ModuleDefLoader.loadFromClassPath(logger, moduleName);
+    StandardLinkerContext linkerContext = new StandardLinkerContext(
+        TreeLogger.NULL, module, options);
+
+    if (!linkerContext.allLinkersAreShardable()) {
+      logger.log(TreeLogger.ERROR,
+          "This compilation mode requires all linkers to be shardable.");
+      return false;
+    }
+
+    Precompile.PrecompileOptions optionsFileData = AnalyzeModule.readAnalyzeModuleOptionsFile(
+        logger, compilerWorkDir);
+    if (optionsFileData == null) {
+      logger.log(TreeLogger.ERROR, "Couldn't find "
+          + AnalyzeModule.OPTIONS_FILENAME + " in " + compilerWorkDir);
+      return false;
+    }
+    logger.log(TreeLogger.INFO, "Precompiling only specified permutations");
+
+    if (options.isValidateOnly()) {
+      TreeLogger branch = logger.branch(TreeLogger.INFO,
+          "Validating compilation " + module.getName());
+      if (!Precompile.validate(branch, options, module, options.getGenDir())) {
+        branch.log(TreeLogger.ERROR, "Validation failed");
+        return false;
+      }
+      branch.log(TreeLogger.INFO, "Validation succeeded");
+    } else {
+      TreeLogger branch = logger.branch(TreeLogger.INFO, "Precompiling module "
+          + module.getName());
+      if (!precompilePermutation(logger, compilerWorkDir, module, branch,
+          permToRun)) {
+        branch.log(TreeLogger.ERROR, "Precompile failed");
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private boolean precompilePermutation(TreeLogger logger,
+      File compilerWorkDir, ModuleDef module, TreeLogger branch, int permId)
+      throws UnableToCompleteException {
+
+    // Only precompile specified permutations
+    List<PropertyPermutations> collapsedPermutations =
+      Precompile.getCollapsedPermutations(module);
+
+    PropertyPermutations onePerm = collapsedPermutations.get(permId);
+    Precompilation precompilation = Precompile.precompile(branch, options,
+        module, permId, onePerm, options.getGenDir());
+    if (precompilation == null) {
+      branch.log(TreeLogger.ERROR, "Precompilation failed");
+      return false;
+    }
+    File precompilationFile = new File(compilerWorkDir,
+        getPrecompileFilename(permId));
+    Util.writeObjectAsFile(logger, precompilationFile, precompilation);
+
+    branch.log(TreeLogger.INFO, "Precompilation succeeded for permutation "
+        + permId);
+
+    return true;
+  }
+}
diff --git a/dev/core/src/com/google/gwt/dev/util/arg/ArgHandlerPerm.java b/dev/core/src/com/google/gwt/dev/util/arg/ArgHandlerPerm.java
new file mode 100644
index 0000000..bb7a6a1
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/util/arg/ArgHandlerPerm.java
@@ -0,0 +1,55 @@
+/*
+ * 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.util.arg;
+
+import com.google.gwt.util.tools.ArgHandlerInt;
+
+/**
+ * Argument handler for specifying the which permutation to run.
+ */
+public class ArgHandlerPerm extends ArgHandlerInt {
+  private final OptionPerm option;
+
+  public ArgHandlerPerm(OptionPerm option) {
+    this.option = option;
+  }
+
+  @Override
+  public String getPurpose() {
+    return "Specifies (0-based) the permutation to compile";
+  }
+
+  @Override
+  public String getTag() {
+    return "-perm";
+  }
+
+  @Override
+  public String[] getTagArgs() {
+    return new String[]{"perm"};
+  }
+
+  @Override
+  public void setInt(int value) {
+    // TODO Auto-generated method stub
+    if (value < 0) {
+      System.err.println(getTag() + " error: negative value '" + value
+          + "' is not allowed");
+    } else {
+      option.setPermToCompile(value);
+    }
+  }
+}
diff --git a/dev/core/src/com/google/gwt/dev/util/arg/OptionPerm.java b/dev/core/src/com/google/gwt/dev/util/arg/OptionPerm.java
new file mode 100644
index 0000000..9d51e98
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/util/arg/OptionPerm.java
@@ -0,0 +1,32 @@
+/*
+ * 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.util.arg;
+
+/**
+ * Handles options for which permutation to compile.
+ */
+public interface OptionPerm {
+  /**
+   * Gets the permutation to compile. Returns -1 if no permutation was
+   * specified.
+   */
+  int getPermToCompile();
+
+  /**
+   * Sets a permutation to compile.
+   */
+  void setPermToCompile(int permToCompile);
+}