diff --git a/dev/core/src/com/google/gwt/dev/CompilePerms.java b/dev/core/src/com/google/gwt/dev/CompilePerms.java
index 69676ae..e9bc22e 100644
--- a/dev/core/src/com/google/gwt/dev/CompilePerms.java
+++ b/dev/core/src/com/google/gwt/dev/CompilePerms.java
@@ -18,9 +18,14 @@
 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.cfg.PropertyPermutations;
 import com.google.gwt.dev.jjs.PermutationResult;
 import com.google.gwt.dev.jjs.UnifiedAst;
 import com.google.gwt.dev.util.FileBackedObject;
+import com.google.gwt.dev.util.Util;
 import com.google.gwt.dev.util.arg.ArgHandlerLocalWorkers;
 import com.google.gwt.dev.util.arg.OptionLocalWorkers;
 import com.google.gwt.util.tools.ArgHandlerString;
@@ -28,7 +33,6 @@
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 import java.util.SortedSet;
 import java.util.TreeSet;
@@ -245,38 +249,21 @@
   }
 
   /**
-   * Check whether any of the listed permutations have their precompilation in
-   * the supplied precompilation file.
-   */
-  private static boolean isPrecompileForAnyOf(
-      PrecompilationFile precompilationFile, int[] permutations) {
-    if (permutations == null) {
-      // Special case: compile everything.
-      return true;
-    }
-    for (int perm : permutations) {
-      if (precompilationFile.isForPermutation(perm)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
    * Choose the subset of requested permutations that correspond to the
    * indicated precompilation.
    */
   private static Permutation[] selectPermutationsForPrecompilation(
-      int[] permsToRun, PrecompilationFile precompilationFile,
-      Precompilation precompilation) {
+      int[] permsToRun, Precompilation precompilation) {
     if (permsToRun == null) {
       // Special case: compile everything.
       return precompilation.getPermutations();
     }
     ArrayList<Permutation> subPermsList = new ArrayList<Permutation>();
-    for (int perm : permsToRun) {
-      if (precompilationFile.isForPermutation(perm)) {
-        subPermsList.add(precompilation.getPermutation(perm));
+    for (int id : permsToRun) {
+      for (Permutation perm : precompilation.getPermutations()) {
+        if (perm.getId() == id) {
+          subPermsList.add(perm);
+        }
       }
     }
     return subPermsList.toArray(new Permutation[subPermsList.size()]);
@@ -296,56 +283,39 @@
       int[] permsToRun = options.getPermsToCompile();
 
       File compilerWorkDir = options.getCompilerWorkDir(moduleName);
-      Collection<PrecompilationFile> precomps;
+      File precompilationFile = new File(compilerWorkDir,
+          Precompile.PRECOMPILE_FILENAME);
+
+      PrecompilationResult precompileResults;
       try {
-        precomps = PrecompilationFile.scanJarFile(new File(compilerWorkDir,
-            Precompile.PRECOMPILE_FILENAME));
+        precompileResults = Util.readFileAsObject(precompilationFile,
+            PrecompilationResult.class);
       } catch (IOException e) {
-        logger.log(TreeLogger.ERROR, "Failed to scan "
-            + Precompile.PRECOMPILE_FILENAME + "; has Precompile been run?", 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;
       }
 
       /*
-       * Check that all requested permutations actually have a Precompile
-       * available
+       * TODO(spoon) Check that all requested permutations have a permutation
+       * available before starting. probably needs two branches.
        */
-      if (permsToRun != null) {
-        checking_perms : for (int perm : permsToRun) {
-          for (PrecompilationFile precomp : precomps) {
-            if (precomp.isForPermutation(perm)) {
-              continue checking_perms;
-            }
-          }
-          logger.log(TreeLogger.ERROR,
-              "No precompilation file found for permutation " + perm);
+
+      if (precompileResults instanceof PrecompileOptions) {
+        PrecompileOptions precompilationOptions = (PrecompileOptions) precompileResults;
+        if (!precompileAndCompile(logger, moduleName, compilerWorkDir,
+            precompilationOptions)) {
           return false;
         }
       } else {
-        // TODO: validate that a contiguous set of all perms exists.
-      }
-
-      /*
-       * Perform the compiles one file at a time, to minimize the number of
-       * times a Precompilation needs to be deserialized.
-       */
-      for (PrecompilationFile precompilationFile : precomps) {
-        if (!isPrecompileForAnyOf(precompilationFile, permsToRun)) {
-          continue;
-        }
-        Precompilation precompilation;
-        try {
-          /*
-           * TODO: don't bother deserializing the generated artifacts.
-           */
-          precompilation = precompilationFile.newInstance(logger);
-        } catch (UnableToCompleteException e) {
-          return false;
-        }
-
+        Precompilation precompilation = (Precompilation) precompileResults;
         // Choose which permutations go with this permutation
         Permutation[] subPerms = selectPermutationsForPrecompilation(
-            permsToRun, precompilationFile, precompilation);
+            permsToRun, precompilation);
 
         List<FileBackedObject<PermutationResult>> resultFiles = makeResultFiles(
             compilerWorkDir, subPerms);
@@ -356,4 +326,63 @@
 
     return true;
   }
+
+  /**
+   * Run both a precompile and a compile with the given precompilation options.
+   */
+  private boolean precompileAndCompile(TreeLogger logger, String moduleName,
+      File compilerWorkDir, PrecompileOptions precompilationOptions)
+      throws UnableToCompleteException {
+    precompilationOptions.setOptimizePrecompile(false);
+    precompilationOptions.setCompilationStateRetained(true);
+    precompilationOptions.setGenDir(null);
+
+    ModuleDef module = ModuleDefLoader.loadFromClassPath(logger, moduleName);
+    PropertyPermutations allPermutations = new PropertyPermutations(
+        module.getProperties());
+    int[] perms = options.getPermsToCompile();
+    if (perms == null) {
+      perms = new int[allPermutations.size()];
+      for (int i = 0; i < perms.length; ++i) {
+        perms[i] = i;
+      }
+    }
+
+    logger = logger.branch(TreeLogger.INFO, "Compiling " + perms.length
+        + " permutation" + (perms.length > 1 ? "s" : ""));
+    for (int permId : perms) {
+      /*
+       * TODO(spoon,scottb): move Precompile out of the loop to run only once
+       * per shard. We'll need a new PropertyPermutations constructor that can
+       * take a precise list. Then figure out a way to avoid copying the
+       * generated artifacts into every perm result on a shard.
+       */
+      module.getCompilationState(logger).refresh(logger);
+      PropertyPermutations onePerm = new PropertyPermutations(allPermutations,
+          permId, 1);
+
+      assert (precompilationOptions.getDumpSignatureFile() == null);
+      Precompilation precompilation = Precompile.precompile(logger,
+          precompilationOptions, module, permId, onePerm,
+          precompilationOptions.getGenDir(), compilerWorkDir, null);
+      if (precompilation == null) {
+        return false;
+      }
+
+      // Choose which permutations go with this precompilation
+      Permutation[] subPerms = selectPermutationsForPrecompilation(
+          new int[] {permId}, precompilation);
+      assert subPerms.length == 1;
+
+      PermutationResult permResult = compile(logger, subPerms[0],
+          precompilation.getUnifiedAst());
+      FileBackedObject<PermutationResult> resultFile = new FileBackedObject<PermutationResult>(
+          PermutationResult.class, makePermFilename(compilerWorkDir, permId));
+      permResult.addArtifacts(precompilation.getGeneratedArtifacts());
+      resultFile.set(logger, permResult);
+    }
+
+    logger.log(TreeLogger.INFO, "Compile of permutations succeeded");
+    return true;
+  }
 }
diff --git a/dev/core/src/com/google/gwt/dev/Compiler.java b/dev/core/src/com/google/gwt/dev/Compiler.java
index 178c37c..99402ed 100644
--- a/dev/core/src/com/google/gwt/dev/Compiler.java
+++ b/dev/core/src/com/google/gwt/dev/Compiler.java
@@ -213,8 +213,8 @@
           File absPath = new File(options.getWarDir(), module.getName());
           absPath = absPath.getAbsoluteFile();
           Link.link(logger.branch(TreeLogger.TRACE, "Linking into " + absPath),
-              module, generatedArtifacts, allPerms, resultFiles,
-              options.getWarDir(), options.getExtraDir(), precompileOptions);
+              module, generatedArtifacts, resultFiles, options.getWarDir(),
+              options.getExtraDir(), precompileOptions);
 
           long compileDone = System.currentTimeMillis();
           long delta = compileDone - compileStart;
diff --git a/dev/core/src/com/google/gwt/dev/GWTCompiler.java b/dev/core/src/com/google/gwt/dev/GWTCompiler.java
index 9e74f56..ba82fe7 100644
--- a/dev/core/src/com/google/gwt/dev/GWTCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/GWTCompiler.java
@@ -204,7 +204,7 @@
 
           Link.legacyLink(logger.branch(TreeLogger.TRACE, "Linking into "
               + options.getOutDir().getPath()), module, generatedArtifacts,
-              allPerms, resultFiles, options.getOutDir(), precompileOptions);
+              resultFiles, options.getOutDir(), precompileOptions);
 
           long compileDone = System.currentTimeMillis();
           long delta = compileDone - compileStart;
diff --git a/dev/core/src/com/google/gwt/dev/Link.java b/dev/core/src/com/google/gwt/dev/Link.java
index 733b25a..92a5ab7 100644
--- a/dev/core/src/com/google/gwt/dev/Link.java
+++ b/dev/core/src/com/google/gwt/dev/Link.java
@@ -22,6 +22,7 @@
 import com.google.gwt.core.ext.linker.impl.StandardCompilationResult;
 import com.google.gwt.core.ext.linker.impl.StandardLinkerContext;
 import com.google.gwt.dev.CompileTaskRunner.CompileTask;
+import com.google.gwt.dev.Precompile.PrecompileOptions;
 import com.google.gwt.dev.cfg.BindingProperty;
 import com.google.gwt.dev.cfg.ModuleDef;
 import com.google.gwt.dev.cfg.ModuleDefLoader;
@@ -45,7 +46,6 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -135,14 +135,14 @@
   }
 
   public static void legacyLink(TreeLogger logger, ModuleDef module,
-      ArtifactSet generatedArtifacts, Permutation[] permutations,
+      ArtifactSet generatedArtifacts,
       List<FileBackedObject<PermutationResult>> resultFiles, File outDir,
       JJSOptions precompileOptions) throws UnableToCompleteException,
       IOException {
     StandardLinkerContext linkerContext = new StandardLinkerContext(logger,
         module, precompileOptions);
     ArtifactSet artifacts = doLink(logger, linkerContext, generatedArtifacts,
-        permutations, resultFiles);
+        resultFiles);
     OutputFileSet outFileSet = new OutputFileSetOnDirectory(outDir,
         module.getName() + "/");
     OutputFileSet extraFileSet = new OutputFileSetOnDirectory(outDir,
@@ -151,14 +151,14 @@
   }
 
   public static void link(TreeLogger logger, ModuleDef module,
-      ArtifactSet generatedArtifacts, Permutation[] permutations,
+      ArtifactSet generatedArtifacts,
       List<FileBackedObject<PermutationResult>> resultFiles, File outDir,
       File extrasDir, JJSOptions precompileOptions)
       throws UnableToCompleteException, IOException {
     StandardLinkerContext linkerContext = new StandardLinkerContext(logger,
         module, precompileOptions);
     ArtifactSet artifacts = doLink(logger, linkerContext, generatedArtifacts,
-        permutations, resultFiles);
+        resultFiles);
     doProduceOutput(logger, artifacts, linkerContext, chooseOutputFileSet(
         outDir, module.getName() + "/"), chooseOutputFileSet(extrasDir,
         module.getName() + "/"));
@@ -189,6 +189,19 @@
   }
 
   /**
+   * Add to a compilation result all of the selection permutations from its
+   * associated permutation.
+   */
+  private static void addSelectionPermutations(
+      StandardCompilationResult compilation, Permutation perm,
+      StandardLinkerContext linkerContext) {
+    for (StaticPropertyOracle propOracle : perm.getPropertyOracles()) {
+      compilation.addSelectionPermutation(computeSelectionPermutation(
+          linkerContext, propOracle));
+    }
+  }
+
+  /**
    * Choose an output file set for the given <code>dirOrJar</code> based on
    * its name, whether it's null, and whether it already exists as a directory.
    */
@@ -219,20 +232,43 @@
     }
   }
 
+  /**
+   * Return a map giving the value of each non-trivial selection property.
+   */
+  private static Map<SelectionProperty, String> computeSelectionPermutation(
+      StandardLinkerContext linkerContext, StaticPropertyOracle propOracle) {
+    BindingProperty[] orderedProps = propOracle.getOrderedProps();
+    String[] orderedPropValues = propOracle.getOrderedPropValues();
+    Map<SelectionProperty, String> unboundProperties = new HashMap<SelectionProperty, String>();
+    for (int i = 0; i < orderedProps.length; i++) {
+      SelectionProperty key = linkerContext.getProperty(orderedProps[i].getName());
+      if (key.tryGetValue() != null) {
+        /*
+         * The view of the Permutation doesn't include properties with defined
+         * values.
+         */
+        continue;
+      } else if (key.isDerived()) {
+        /*
+         * The property provider does not need to be invoked, because the value
+         * is determined entirely by other properties.
+         */
+        continue;
+      }
+      unboundProperties.put(key, orderedPropValues[i]);
+    }
+    return unboundProperties;
+  }
+
   private static ArtifactSet doLink(TreeLogger logger,
       StandardLinkerContext linkerContext, ArtifactSet generatedArtifacts,
-      Permutation[] perms, List<FileBackedObject<PermutationResult>> resultFiles)
+      List<FileBackedObject<PermutationResult>> resultFiles)
       throws UnableToCompleteException {
-    if (perms.length != resultFiles.size()) {
-      throw new IllegalArgumentException(
-          "Mismatched resultFiles.length and permutation count");
-    }
-
-    for (int i = 0; i < perms.length; ++i) {
-      finishPermuation(logger, perms[i], resultFiles.get(i), linkerContext);
-    }
-
     linkerContext.addOrReplaceArtifacts(generatedArtifacts);
+    for (FileBackedObject<PermutationResult> resultFile : resultFiles) {
+      PermutationResult result = resultFile.newInstance(logger);
+      finishPermutation(logger, result.getPermutation(), result, linkerContext);
+    }
     return linkerContext.invokeLink(logger);
   }
 
@@ -251,35 +287,13 @@
     logger.log(TreeLogger.INFO, "Link succeeded");
   }
 
-  private static void finishPermuation(TreeLogger logger, Permutation perm,
-      FileBackedObject<PermutationResult> resultFile,
-      StandardLinkerContext linkerContext) throws UnableToCompleteException {
-    PermutationResult permutationResult = resultFile.newInstance(logger);
-    StandardCompilationResult compilation = linkerContext.getCompilation(permutationResult);
-    StaticPropertyOracle[] propOracles = perm.getPropertyOracles();
-    for (StaticPropertyOracle propOracle : propOracles) {
-      BindingProperty[] orderedProps = propOracle.getOrderedProps();
-      String[] orderedPropValues = propOracle.getOrderedPropValues();
-      Map<SelectionProperty, String> unboundProperties = new HashMap<SelectionProperty, String>();
-      for (int i = 0; i < orderedProps.length; i++) {
-        SelectionProperty key = linkerContext.getProperty(orderedProps[i].getName());
-        if (key.tryGetValue() != null) {
-          /*
-           * The view of the Permutation doesn't include properties with defined
-           * values.
-           */
-          continue;
-        } else if (key.isDerived()) {
-          /*
-           * The property provider does not need to be invoked, because the
-           * value is determined entirely by other properties.
-           */
-          continue;
-        }
-        unboundProperties.put(key, orderedPropValues[i]);
-      }
-      compilation.addSelectionPermutation(unboundProperties);
-    }
+  /**
+   * Add a compilation to a linker context.
+   */
+  private static void finishPermutation(TreeLogger logger, Permutation perm,
+      PermutationResult permResult, StandardLinkerContext linkerContext) {
+    StandardCompilationResult compilation = linkerContext.getCompilation(permResult);
+    addSelectionPermutations(compilation, perm, linkerContext);
     logScriptSize(logger, perm.getId(), compilation);
   }
 
@@ -315,17 +329,6 @@
 
   public boolean run(TreeLogger logger) throws UnableToCompleteException {
     for (String moduleName : options.getModuleNames()) {
-      File compilerWorkDir = options.getCompilerWorkDir(moduleName);
-      Collection<PrecompilationFile> precomps;
-      try {
-        precomps = PrecompilationFile.scanJarFile(new File(compilerWorkDir,
-            Precompile.PRECOMPILE_FILENAME));
-      } catch (IOException e) {
-        logger.log(TreeLogger.ERROR, "Failed to scan "
-            + Precompile.PRECOMPILE_FILENAME, e);
-        return false;
-      }
-
       ModuleDef module = ModuleDefLoader.loadFromClassPath(logger, moduleName);
 
       OutputFileSet outFileSet;
@@ -357,36 +360,53 @@
         throw new UnableToCompleteException();
       }
 
-      if (precomps.isEmpty()) {
-        logger.log(TreeLogger.ERROR, "No precompilation files found in '"
-            + compilerWorkDir.getAbsolutePath()
-            + "'; please run Precompile first");
-        return false;
-      }
-
       List<Permutation> permsList = new ArrayList<Permutation>();
       ArtifactSet generatedArtifacts = new ArtifactSet();
       JJSOptions precompileOptions = null;
 
-      for (PrecompilationFile precompilationFile : precomps) {
-        Precompilation precompilation;
-        try {
-          precompilation = precompilationFile.newInstance(logger);
-        } catch (UnableToCompleteException e) {
-          return false;
+      File compilerWorkDir = options.getCompilerWorkDir(moduleName);
+      List<Integer> permutationIds = new ArrayList<Integer>();
+      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;
+      }
+
+      if (precompileResults instanceof PrecompileOptions) {
+        /**
+         * Precompiling happened on the shards.
+         */
+        precompileOptions = (JJSOptions) precompileResults;
+        int numPermutations = module.getProperties().numPermutations();
+        for (int i = 0; i < numPermutations; ++i) {
+          permutationIds.add(i);
         }
+      } else {
+        /**
+         * Precompiling happened on the start node.
+         */
+        Precompilation precompilation = (Precompilation) precompileResults;
         permsList.addAll(Arrays.asList(precompilation.getPermutations()));
         generatedArtifacts.addAll(precompilation.getGeneratedArtifacts());
         precompileOptions = precompilation.getUnifiedAst().getOptions();
+
+        for (Permutation perm : precompilation.getPermutations()) {
+          permutationIds.add(perm.getId());
+        }
       }
 
-      Permutation[] perms = permsList.toArray(new Permutation[permsList.size()]);
-
       List<FileBackedObject<PermutationResult>> resultFiles = new ArrayList<FileBackedObject<PermutationResult>>(
-          perms.length);
-      for (int i = 0; i < perms.length; ++i) {
-        File f = CompilePerms.makePermFilename(compilerWorkDir,
-            perms[i].getId());
+          permutationIds.size());
+      for (int id : permutationIds) {
+        File f = CompilePerms.makePermFilename(compilerWorkDir, id);
         if (!f.exists()) {
           logger.log(TreeLogger.ERROR, "File not found '" + f.getAbsolutePath()
               + "'; please compile all permutations");
@@ -402,8 +422,7 @@
           module, precompileOptions);
 
       ArtifactSet artifacts = doLink(branch, linkerContext, generatedArtifacts,
-          perms, resultFiles);
-
+          resultFiles);
       try {
         doProduceOutput(branch, artifacts, linkerContext, outFileSet,
             extraFileSet);
diff --git a/dev/core/src/com/google/gwt/dev/Precompilation.java b/dev/core/src/com/google/gwt/dev/Precompilation.java
index ac6c25a..c8b68b5 100644
--- a/dev/core/src/com/google/gwt/dev/Precompilation.java
+++ b/dev/core/src/com/google/gwt/dev/Precompilation.java
@@ -17,7 +17,13 @@
 
 import com.google.gwt.core.ext.linker.ArtifactSet;
 import com.google.gwt.dev.jjs.UnifiedAst;
+import com.google.gwt.dev.util.Util;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.util.Collection;
 
@@ -25,13 +31,14 @@
  * The result of compilation phase 1, includes a unified AST and metadata
  * relevant to each permutation.
  */
-public class Precompilation implements Serializable {
+public class Precompilation implements Serializable, PrecompilationResult {
   /*
    * TODO: don't make this whole class serializable, instead dump the
    * independent members out to a file so that the generated artifacts are
    * optional to deserialize.
    */
-  private ArtifactSet generatedArtifacts;
+  private transient ArtifactSet generatedArtifacts;
+  private transient byte[] generatedArtifactsSerialized;
   private final Permutation[] permutations;
   private final UnifiedAst unifiedAst;
 
@@ -68,6 +75,20 @@
    * Returns the set of generated artifacts from the precompile phase.
    */
   public ArtifactSet getGeneratedArtifacts() {
+    if (generatedArtifacts == null) {
+      try {
+        assert generatedArtifactsSerialized != null;
+        generatedArtifacts = Util.readStreamAsObject(new ByteArrayInputStream(
+            generatedArtifactsSerialized), ArtifactSet.class);
+        generatedArtifactsSerialized = null;
+      } catch (ClassNotFoundException e) {
+        throw new RuntimeException(
+            "Unexpected exception deserializing from memory stream", e);
+      } catch (IOException e) {
+        throw new RuntimeException(
+            "Unexpected exception deserializing from memory stream", e);
+      }
+    }
     return generatedArtifacts;
   }
 
@@ -94,4 +115,17 @@
   public UnifiedAst getUnifiedAst() {
     return unifiedAst;
   }
+
+  private void readObject(ObjectInputStream stream) throws IOException,
+      ClassNotFoundException {
+    stream.defaultReadObject();
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    Util.copyNoClose(stream, baos);
+    generatedArtifactsSerialized = baos.toByteArray();
+  }
+
+  private void writeObject(ObjectOutputStream stream) throws IOException {
+    stream.defaultWriteObject();
+    Util.writeObjectToStream(stream, generatedArtifacts);
+  }
 }
diff --git a/dev/core/src/com/google/gwt/dev/PrecompilationFile.java b/dev/core/src/com/google/gwt/dev/PrecompilationFile.java
deleted file mode 100644
index 231daf2..0000000
--- a/dev/core/src/com/google/gwt/dev/PrecompilationFile.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright 2009 Google Inc.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.google.gwt.dev;
-
-import com.google.gwt.core.ext.TreeLogger;
-import com.google.gwt.core.ext.UnableToCompleteException;
-import com.google.gwt.dev.util.Util;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Enumeration;
-import java.util.List;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.zip.ZipEntry;
-
-/**
- * The backing file for a {@link Precompilation} for a subset of the
- * permutations for a compilation. The permutations this one is for are in a
- * consecutive range described by {@link #getFirstPerm()} and
- * {@link #getNumPerms()}.
- */
-public class PrecompilationFile {
-  /**
-   * Suffix for precompilation files stored in the work directory.
-   */
-  private static final String FILENAME_PREFIX = "precompilation";
-
-  /**
-   * Prefix for precompilation files stored in the work directory.
-   */
-  private static final String FILENAME_SUFFIX = ".ser";
-
-  public static String fileNameForPermutations(int firstPerm, int numPerms) {
-    return FILENAME_PREFIX + firstPerm + "-" + (firstPerm + numPerms - 1)
-        + FILENAME_SUFFIX;
-  }
-
-  public static Collection<PrecompilationFile> scanJarFile(File file)
-      throws IOException {
-    Pattern pattern = Pattern.compile("precompilation([0-9]+)-([0-9]+)\\.ser");
-
-    List<PrecompilationFile> precomps = new ArrayList<PrecompilationFile>();
-
-    JarFile jarFile = new JarFile(file);
-    Enumeration<JarEntry> entries = jarFile.entries();
-    while (entries.hasMoreElements()) {
-      JarEntry entry = entries.nextElement();
-      Matcher matcher = pattern.matcher(entry.getName());
-      if (matcher.matches()) {
-        int start = Integer.parseInt(matcher.group(1));
-        int end = Integer.parseInt(matcher.group(2));
-        int numPerms = end - start + 1;
-
-        precomps.add(new PrecompilationFile(jarFile, entry, start, numPerms));
-      }
-    }
-
-    return precomps;
-  }
-
-  private final JarFile jarFile;
-  private final ZipEntry zipEntry;
-
-  private final int firstPerm;
-
-  private final int numPerms;
-
-  public PrecompilationFile(JarFile jarFile, ZipEntry zipEntry, int firstPerm,
-      int numPerms) {
-    this.firstPerm = firstPerm;
-    this.numPerms = numPerms;
-
-    this.jarFile = jarFile;
-    this.zipEntry = zipEntry;
-  }
-
-  /**
-   * Return the first permutation this {@link Precompilation} is for.
-   */
-  public int getFirstPerm() {
-    return firstPerm;
-  }
-
-  /**
-   * Get the number of the highest permutation included in this
-   * {@link Precompilation}.
-   */
-  public int getLastPerm() {
-    return getFirstPerm() + getNumPerms() - 1;
-  }
-
-  /**
-   * Return the number of permutations in this {@link Precompilation}.
-   */
-  public int getNumPerms() {
-    return numPerms;
-  }
-
-  public boolean isForPermutation(int perm) {
-    return perm >= getFirstPerm() && perm <= getLastPerm();
-  }
-
-  public Precompilation newInstance(TreeLogger logger)
-      throws UnableToCompleteException {
-    try {
-      return Util.readStreamAsObject(jarFile.getInputStream(zipEntry),
-          Precompilation.class);
-    } catch (IOException e) {
-      logger.log(TreeLogger.ERROR, "Unable to instantiate object", e);
-      throw new UnableToCompleteException();
-    } catch (ClassNotFoundException e) {
-      logger.log(TreeLogger.ERROR, "Missing class definition", e);
-      throw new UnableToCompleteException();
-    }
-  }
-}
diff --git a/dev/core/src/com/google/gwt/dev/PrecompilationResult.java b/dev/core/src/com/google/gwt/dev/PrecompilationResult.java
new file mode 100644
index 0000000..d342254
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/PrecompilationResult.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev;
+
+import java.io.Serializable;
+
+/**
+ * A result of running {@link Precompile}. It's either a {@link Precompilation}
+ * or, if precompiles are going to happen on compile shards, an instance of
+ * {@link com.google.gwt.dev.Precompile.PrecompileOptions}.
+ */
+public interface PrecompilationResult extends Serializable {
+}
diff --git a/dev/core/src/com/google/gwt/dev/Precompile.java b/dev/core/src/com/google/gwt/dev/Precompile.java
index 435465b..23316cb 100644
--- a/dev/core/src/com/google/gwt/dev/Precompile.java
+++ b/dev/core/src/com/google/gwt/dev/Precompile.java
@@ -54,19 +54,20 @@
 import com.google.gwt.dev.util.arg.ArgHandlerEnableAssertions;
 import com.google.gwt.dev.util.arg.ArgHandlerGenDir;
 import com.google.gwt.dev.util.arg.ArgHandlerMaxPermsPerPrecompile;
+import com.google.gwt.dev.util.arg.ArgHandlerShardPrecompile;
 import com.google.gwt.dev.util.arg.ArgHandlerScriptStyle;
 import com.google.gwt.dev.util.arg.ArgHandlerSoyc;
 import com.google.gwt.dev.util.arg.ArgHandlerSoycDetailed;
 import com.google.gwt.dev.util.arg.ArgHandlerValidateOnlyFlag;
 import com.google.gwt.dev.util.arg.OptionDisableUpdateCheck;
 import com.google.gwt.dev.util.arg.OptionDumpSignatures;
+import com.google.gwt.dev.util.arg.OptionEnableGeneratingOnShards;
 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 java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
+import java.io.Serializable;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
@@ -74,8 +75,6 @@
 import java.util.SortedSet;
 import java.util.TreeMap;
 import java.util.concurrent.FutureTask;
-import java.util.jar.JarOutputStream;
-import java.util.zip.ZipEntry;
 
 /**
  * Performs the first phase of compilation, generating the set of permutations
@@ -88,7 +87,8 @@
    */
   public interface PrecompileOptions extends JJSOptions, CompileTaskOptions,
       OptionGenDir, OptionValidateOnly, OptionDisableUpdateCheck,
-      OptionDumpSignatures, OptionMaxPermsPerPrecompile {
+      OptionDumpSignatures, OptionEnableGeneratingOnShards,
+      OptionMaxPermsPerPrecompile, PrecompilationResult {
   }
 
   static class ArgProcessor extends CompileArgProcessor {
@@ -97,6 +97,7 @@
       registerHandler(new ArgHandlerGenDir(options));
       registerHandler(new ArgHandlerScriptStyle(options));
       registerHandler(new ArgHandlerEnableAssertions(options));
+      registerHandler(new ArgHandlerShardPrecompile(options));
       registerHandler(new ArgHandlerDisableAggressiveOptimization(options));
       registerHandler(new ArgHandlerDisableClassMetadata(options));
       registerHandler(new ArgHandlerDisableCastChecking(options));
@@ -118,9 +119,10 @@
   }
 
   static class PrecompileOptionsImpl extends CompileTaskOptionsImpl implements
-      PrecompileOptions {
+      PrecompileOptions, Serializable {
     private boolean disableUpdateCheck;
     private File dumpFile;
+    private boolean enableGeneratingOnShards;
     private File genDir;
     private final JJSOptionsImpl jjsOptions = new JJSOptionsImpl();
     private int maxPermsPerPrecompile;
@@ -143,6 +145,7 @@
       setGenDir(other.getGenDir());
       setMaxPermsPerPrecompile(other.getMaxPermsPerPrecompile());
       setValidateOnly(other.isValidateOnly());
+      setEnabledGeneratingOnShards(other.isEnabledGeneratingOnShards());
     }
 
     public File getDumpSignatureFile() {
@@ -185,6 +188,10 @@
       return jjsOptions.isEnableAssertions();
     }
 
+    public boolean isEnabledGeneratingOnShards() {
+      return enableGeneratingOnShards;
+    }
+
     public boolean isOptimizePrecompile() {
       return jjsOptions.isOptimizePrecompile();
     }
@@ -241,6 +248,10 @@
       jjsOptions.setEnableAssertions(enableAssertions);
     }
 
+    public void setEnabledGeneratingOnShards(boolean enabled) {
+      enableGeneratingOnShards = enabled;
+    }
+
     public void setGenDir(File genDir) {
       this.genDir = genDir;
     }
@@ -460,30 +471,8 @@
     }
   }
 
-  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);
-  }
-
-  private static Precompilation precompile(TreeLogger logger,
-      JJSOptions jjsOptions, ModuleDef module, int permutationBase,
+  static Precompilation precompile(TreeLogger logger, JJSOptions jjsOptions,
+      ModuleDef module, int permutationBase,
       PropertyPermutations allPermutations, File genDir,
       File generatorResourcesDir, File dumpSignatureFile) {
 
@@ -506,9 +495,8 @@
           module, compilationState, generatedArtifacts, allPermutations,
           genDir, generatorResourcesDir);
       PerfLogger.start("Precompile");
-      UnifiedAst unifiedAst = getCompiler(module).precompile(logger,
-          module, rpo, declEntryPts, null, jjsOptions,
-          rpo.getPermuationCount() == 1);
+      UnifiedAst unifiedAst = getCompiler(module).precompile(logger, module,
+          rpo, declEntryPts, null, jjsOptions, rpo.getPermuationCount() == 1);
       PerfLogger.end();
 
       // Merge all identical permutations together.
@@ -538,6 +526,28 @@
     }
   }
 
+  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);
+  }
+
   private final PrecompileOptionsImpl options;
 
   public Precompile(PrecompileOptions options) {
@@ -545,7 +555,6 @@
   }
 
   public boolean run(TreeLogger logger) throws UnableToCompleteException {
-    boolean originalCompilationStateRetained = options.isCompilationStateRetained();
     // Avoid early optimizations since permutation compiles will run separately.
     options.setOptimizePrecompile(false);
 
@@ -555,116 +564,76 @@
       // No need to check mkdirs result because an IOException will occur anyway
       compilerWorkDir.mkdirs();
 
-      JarOutputStream precompilationJar;
-      try {
-        precompilationJar = new JarOutputStream(new FileOutputStream(new File(
-            compilerWorkDir, PRECOMPILE_FILENAME)));
-      } catch (IOException e) {
-        logger.log(TreeLogger.ERROR, "Could not create " + PRECOMPILE_FILENAME,
-            e);
-        return false;
-      }
+      File precompilationFile = new File(compilerWorkDir, PRECOMPILE_FILENAME);
 
       ModuleDef module = ModuleDefLoader.loadFromClassPath(logger, moduleName);
 
-      // TODO: All JDT checks now before even building TypeOracle?
-      module.getCompilationState(logger);
-
+      boolean generateOnShards = options.isEnabledGeneratingOnShards();
       if (options.isValidateOnly()) {
-        TreeLogger branch = logger.branch(TreeLogger.INFO,
-            "Validating compilation " + module.getName());
-        if (!validate(branch, options, module, options.getGenDir(),
-            compilerWorkDir, options.getDumpSignatureFile())) {
-          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());
-        PropertyPermutations allPermutations = new PropertyPermutations(
-            module.getProperties());
-        int potentialPermutations = allPermutations.size();
-        int permutationsPerIteration = options.getMaxPermsPerPrecompile();
-
-        if (permutationsPerIteration <= 0) {
-          permutationsPerIteration = potentialPermutations;
-        }
+        // Don't bother running on shards for just a validation run
+        generateOnShards = false;
+      } else if (options.getDumpSignatureFile() != null) {
+        logger.log(TreeLogger.INFO,
+            "Precompiling on the start node, because a dump signature file was specified");
         /*
-         * The potential number of permutations to precompile >= the actual
-         * number of permutations that end up being precompiled, because some of
-         * the permutations might collapse due to identical rebind results. So
-         * we have to track these two counts and ids separately.
+         * It would be possible to shard in this case, too. However, each
+         * permutation would have its own signatures dumped. Either the output
+         * would need to be multiple dump files, or those files would need to be
+         * combined back into one.
          */
-        int actualPermutations = 0;
-        for (int potentialFirstPerm = 0; potentialFirstPerm < potentialPermutations; potentialFirstPerm += permutationsPerIteration) {
-          int numPermsToPrecompile = Math.min(potentialPermutations
-              - potentialFirstPerm, permutationsPerIteration);
+        generateOnShards = false;
+      }
 
-          /*
-           * After the first precompile, we need to forcibly refresh
-           * CompilationState to clear out generated units from previous
-           * precompilations.
-           */
-          if (potentialFirstPerm != 0) {
-            module.getCompilationState(branch).refresh(branch);
+      if (generateOnShards) {
+        /*
+         * Pre-precompile. Count the permutations and plan to do a real
+         * precompile in the CompilePerms shards.
+         */
+        TreeLogger branch = logger.branch(TreeLogger.INFO,
+            "Precompiling (minimal) module " + module.getName());
+        Util.writeObjectAsFile(logger, precompilationFile, options);
+        int numPermutations = module.getProperties().numPermutations();
+        Util.writeStringAsFile(logger, new File(compilerWorkDir,
+            PERM_COUNT_FILENAME), String.valueOf(numPermutations));
+        branch.log(TreeLogger.INFO,
+            "Precompilation (minimal) succeeded, number of permutations: "
+                + numPermutations);
+      } else {
+        // TODO: All JDT checks now before even building TypeOracle?
+        module.getCompilationState(logger);
+
+        if (options.isValidateOnly()) {
+          TreeLogger branch = logger.branch(TreeLogger.INFO,
+              "Validating compilation " + module.getName());
+          if (!validate(branch, options, module, options.getGenDir(),
+              compilerWorkDir, options.getDumpSignatureFile())) {
+            branch.log(TreeLogger.ERROR, "Validation failed");
+            return false;
           }
-
-          if (potentialFirstPerm + numPermsToPrecompile < potentialPermutations) {
-            /*
-             * On all iterations but the last, force retainCompilationState to
-             * be true. Otherwise, state will be discarded that is needed on
-             * later iterations.
-             */
-            options.setCompilationStateRetained(true);
-          } else {
-            // On the last iteration, use whatever the original setting was
-            options.setCompilationStateRetained(originalCompilationStateRetained);
-          }
-
-          // Select only the range of property permutations that we want
-          PropertyPermutations localPermutations = new PropertyPermutations(
-              allPermutations, potentialFirstPerm, numPermsToPrecompile);
+          branch.log(TreeLogger.INFO, "Validation succeeded");
+        } else {
+          TreeLogger branch = logger.branch(TreeLogger.INFO,
+              "Precompiling module " + module.getName());
 
           Precompilation precompilation = precompile(branch, options, module,
-              actualPermutations, localPermutations, options.getGenDir(),
-              compilerWorkDir, options.getDumpSignatureFile());
+              options.getGenDir(), compilerWorkDir,
+              options.getDumpSignatureFile());
           if (precompilation == null) {
             branch.log(TreeLogger.ERROR, "Precompilation failed");
             return false;
           }
-          int actualNumPermsPrecompiled = precompilation.getPermutations().length;
-          String precompilationFilename = PrecompilationFile.fileNameForPermutations(
-              actualPermutations, actualNumPermsPrecompiled);
-          try {
-            precompilationJar.putNextEntry(new ZipEntry(precompilationFilename));
-            Util.writeObjectToStream(precompilationJar, precompilation);
-          } catch (IOException e) {
-            branch.log(TreeLogger.ERROR,
-                "Failed to write a precompilation result", e);
-            return false;
-          }
+          Util.writeObjectAsFile(logger, precompilationFile, precompilation);
 
-          actualPermutations += actualNumPermsPrecompiled;
-          branch.log(TreeLogger.DEBUG, "Compiled " + actualNumPermsPrecompiled
-              + " permutations starting from " + potentialFirstPerm);
+          int permsPrecompiled = precompilation.getPermutations().length;
+          Util.writeStringAsFile(logger, new File(compilerWorkDir,
+              PERM_COUNT_FILENAME), String.valueOf(permsPrecompiled));
+          branch.log(TreeLogger.INFO,
+              "Precompilation succeeded, number of permutations: "
+                  + permsPrecompiled);
         }
-
-        try {
-          precompilationJar.close();
-        } catch (IOException e) {
-          branch.log(TreeLogger.ERROR, "Failed to finalize "
-              + PRECOMPILE_FILENAME, e);
-          return false;
-        }
-
-        Util.writeStringAsFile(branch, new File(compilerWorkDir,
-            PERM_COUNT_FILENAME), String.valueOf(actualPermutations));
-        branch.log(TreeLogger.INFO,
-            "Precompilation succeeded, number of permutations: "
-                + actualPermutations);
       }
     }
+
     return true;
   }
 }
diff --git a/dev/core/src/com/google/gwt/dev/cfg/Properties.java b/dev/core/src/com/google/gwt/dev/cfg/Properties.java
index b3b6d86..be15e15 100644
--- a/dev/core/src/com/google/gwt/dev/cfg/Properties.java
+++ b/dev/core/src/com/google/gwt/dev/cfg/Properties.java
@@ -74,6 +74,15 @@
     return map.values().iterator();
   }
 
+  /**
+   * Count the total number of permutations that this property set supports.
+   * This method can be expensive because it always recalculates the answer
+   * based on the current set of properties and values.
+   */
+  public int numPermutations() {
+    return new PropertyPermutations(this).size();
+  }
+
   private <T extends Property> T create(String name, boolean flag,
       boolean useFlagArgument, Class<T> clazz) {
     if (clazz == null) {
diff --git a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
index 1a1aa8f..93c4a11 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
@@ -172,6 +172,10 @@
       this.statementRanges = statementRanges;
     }
 
+    public void addArtifacts(Collection<? extends Artifact<?>> newArtifacts) {
+      this.artifacts.addAll(newArtifacts);
+    }
+
     public ArtifactSet getArtifacts() {
       return artifacts;
     }
@@ -356,9 +360,8 @@
 
       PermutationResult toReturn = new PermutationResultImpl(js, permutation,
           makeSymbolMap(symbolTable), ranges);
-      toReturn.getArtifacts().addAll(
-          makeSoycArtifacts(logger, permutationId, jprogram, js,
-              sizeBreakdowns, sourceInfoMaps, dependencies, map, obfuscateMap));
+      toReturn.addArtifacts(makeSoycArtifacts(logger, permutationId, jprogram,
+          js, sizeBreakdowns, sourceInfoMaps, dependencies, map, obfuscateMap));
 
       logger.log(TreeLogger.TRACE, "Permutation took "
           + (System.currentTimeMillis() - permStart) + " ms");
diff --git a/dev/core/src/com/google/gwt/dev/jjs/PermutationResult.java b/dev/core/src/com/google/gwt/dev/jjs/PermutationResult.java
index 28002ff..88ad66a 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/PermutationResult.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/PermutationResult.java
@@ -15,11 +15,13 @@
  */
 package com.google.gwt.dev.jjs;
 
+import com.google.gwt.core.ext.linker.Artifact;
 import com.google.gwt.core.ext.linker.ArtifactSet;
 import com.google.gwt.core.ext.linker.StatementRanges;
 import com.google.gwt.dev.Permutation;
 
 import java.io.Serializable;
+import java.util.Collection;
 
 /**
  * An extensible return type for the results of compiling a single permutation.
@@ -27,6 +29,11 @@
 public interface PermutationResult extends Serializable {
 
   /**
+   * Adds additional artifacts to this permutation result.
+   */
+  void addArtifacts(Collection<? extends Artifact<?>> newArtifacts);
+
+  /**
    * Returns any Artifacts that may have been created as a result of compiling
    * the permutation.
    */
diff --git a/dev/core/src/com/google/gwt/dev/util/arg/ArgHandlerShardPrecompile.java b/dev/core/src/com/google/gwt/dev/util/arg/ArgHandlerShardPrecompile.java
new file mode 100644
index 0000000..706895d
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/util/arg/ArgHandlerShardPrecompile.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.util.arg;
+
+import com.google.gwt.util.tools.ArgHandlerFlag;
+
+/**
+ * An argument handler that enables running generators on shards.
+ */
+public class ArgHandlerShardPrecompile extends ArgHandlerFlag {
+  private OptionEnableGeneratingOnShards options;
+
+  public ArgHandlerShardPrecompile(OptionEnableGeneratingOnShards options) {
+    this.options = options;
+  }
+
+  @Override
+  public String getPurpose() {
+    return "Enables running generators on CompilePerms shards";
+  }
+
+  @Override
+  public String getTag() {
+    return "-XshardPrecompile";
+  }
+
+  @Override
+  public boolean setFlag() {
+    options.setEnabledGeneratingOnShards(true);
+    return true;
+  }
+}
diff --git a/dev/core/src/com/google/gwt/dev/util/arg/OptionEnableGeneratingOnShards.java b/dev/core/src/com/google/gwt/dev/util/arg/OptionEnableGeneratingOnShards.java
new file mode 100644
index 0000000..8afd1d8
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/util/arg/OptionEnableGeneratingOnShards.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.util.arg;
+
+/**
+ * Enables running generators on compile shards rather than during the
+ * Precompile stage.
+ */
+public interface OptionEnableGeneratingOnShards {
+  /**
+   * Returns <code>true</code> if generation is allowed to happen on shards.
+   */
+  boolean isEnabledGeneratingOnShards();
+
+  /**
+   * Sets whether generation may happen on shards.
+   */
+  void setEnabledGeneratingOnShards(boolean allowed);
+}