diff --git a/dev/core/src/com/google/gwt/dev/jdt/BasicWebModeCompiler.java b/dev/core/src/com/google/gwt/dev/jdt/BasicWebModeCompiler.java
new file mode 100644
index 0000000..8937921
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/jdt/BasicWebModeCompiler.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.jdt;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.core.ext.typeinfo.TypeOracle;
+import com.google.gwt.dev.javac.CompilationState;
+import com.google.gwt.dev.javac.CompilationUnit;
+import com.google.gwt.dev.javac.CompiledClass;
+import com.google.gwt.dev.javac.JdtCompiler.CompilationUnitAdapter;
+import com.google.gwt.dev.util.Empty;
+import com.google.gwt.dev.util.JsniRef;
+import com.google.gwt.dev.util.Memory;
+
+import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
+import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Provides a basic front-end based on the JDT compiler that incorporates
+ * GWT-specific concepts such as JSNI.
+ */
+public class BasicWebModeCompiler extends AbstractCompiler {
+
+  public static CompilationUnitDeclaration[] getCompilationUnitDeclarations(
+      TreeLogger logger, CompilationState state, String... seedTypeNames)
+      throws UnableToCompleteException {
+    return new BasicWebModeCompiler(state).getCompilationUnitDeclarations(
+        logger, seedTypeNames);
+  }
+
+  /**
+   * Construct a BasicWebModeCompiler.
+   */
+  public BasicWebModeCompiler(CompilationState compilationState) {
+    super(compilationState, false);
+  }
+
+  /**
+   * Build the initial set of compilation units.
+   */
+  public CompilationUnitDeclaration[] getCompilationUnitDeclarations(
+      TreeLogger logger, String[] seedTypeNames)
+      throws UnableToCompleteException {
+
+    TypeOracle oracle = compilationState.getTypeOracle();
+    Set<JClassType> intfTypes = oracle.getSingleJsoImplInterfaces();
+    Map<String, CompiledClass> classMapBySource = compilationState.getClassFileMapBySource();
+
+    /*
+     * The alreadyAdded set prevents duplicate CompilationUnits from being added
+     * to the icu list in the case of multiple JSO implementations as inner
+     * classes in the same top-level class or seed classes as SingleJsoImpls
+     * (e.g. JSO itself as the SingleImpl for all tag interfaces).
+     */
+    Set<CompilationUnit> alreadyAdded = new HashSet<CompilationUnit>();
+
+    List<ICompilationUnit> icus = new ArrayList<ICompilationUnit>(
+        seedTypeNames.length + intfTypes.size());
+
+    for (String seedTypeName : seedTypeNames) {
+      CompilationUnit unit = getUnitForType(logger, classMapBySource,
+          seedTypeName);
+
+      if (alreadyAdded.add(unit)) {
+        icus.add(new CompilationUnitAdapter(unit));
+      } else {
+        logger.log(TreeLogger.WARN, "Duplicate compilation unit '"
+            + unit.getDisplayLocation() + "'in seed types");
+      }
+    }
+
+    /*
+     * Add all SingleJsoImpl types that we know about. It's likely that the
+     * concrete types are never explicitly referenced from the seed types.
+     */
+    for (JClassType intf : intfTypes) {
+      String implName = oracle.getSingleJsoImpl(intf).getQualifiedSourceName();
+      CompilationUnit unit = getUnitForType(logger, classMapBySource, implName);
+
+      if (alreadyAdded.add(unit)) {
+        icus.add(new CompilationUnitAdapter(unit));
+        logger.log(TreeLogger.SPAM, "Forced compilation of unit '"
+            + unit.getDisplayLocation()
+            + "' becasue it contains a SingleJsoImpl type");
+      }
+    }
+
+    /*
+     * Compile, which will pull in everything else via the
+     * doFindAdditionalTypesUsingFoo() methods.
+     */
+    CompilationUnitDeclaration[] cuds = compile(logger,
+        icus.toArray(new ICompilationUnit[icus.size()]));
+    Memory.maybeDumpMemory("WebModeCompiler");
+    return cuds;
+  }
+
+  /**
+   * Pull in types referenced only via JSNI.
+   */
+  @Override
+  protected String[] doFindAdditionalTypesUsingJsni(TreeLogger logger,
+      CompilationUnitDeclaration cud) {
+    FindJsniRefVisitor v = new FindJsniRefVisitor();
+    cud.traverse(v, cud.scope);
+    Set<String> jsniRefs = v.getJsniRefs();
+    Set<String> dependentTypeNames = new HashSet<String>();
+    for (String jsniRef : jsniRefs) {
+      JsniRef parsed = JsniRef.parse(jsniRef);
+      if (parsed != null) {
+        // If we fail to parse, don't add a class reference.
+        dependentTypeNames.add(parsed.className());
+      }
+    }
+    return dependentTypeNames.toArray(Empty.STRINGS);
+  }
+
+  /**
+   * Get the CompilationUnit for a named type or throw an
+   * UnableToCompleteException.
+   */
+  private CompilationUnit getUnitForType(TreeLogger logger,
+      Map<String, CompiledClass> classMapBySource, String typeName)
+      throws UnableToCompleteException {
+
+    CompiledClass compiledClass = classMapBySource.get(typeName);
+    if (compiledClass == null) {
+      logger.log(TreeLogger.ERROR, "Unable to find compilation unit for type '"
+          + typeName + "'");
+      throw new UnableToCompleteException();
+    }
+
+    assert compiledClass.getUnit() != null;
+    return compiledClass.getUnit();
+  }
+}
diff --git a/dev/core/src/com/google/gwt/dev/jdt/WebModeCompilerFrontEnd.java b/dev/core/src/com/google/gwt/dev/jdt/WebModeCompilerFrontEnd.java
index e9925b3..77b7665 100644
--- a/dev/core/src/com/google/gwt/dev/jdt/WebModeCompilerFrontEnd.java
+++ b/dev/core/src/com/google/gwt/dev/jdt/WebModeCompilerFrontEnd.java
@@ -17,26 +17,17 @@
 
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
-import com.google.gwt.core.ext.typeinfo.JClassType;
-import com.google.gwt.core.ext.typeinfo.TypeOracle;
 import com.google.gwt.dev.javac.ArtificialRescueChecker;
 import com.google.gwt.dev.javac.CompilationState;
-import com.google.gwt.dev.javac.CompilationUnit;
-import com.google.gwt.dev.javac.CompiledClass;
-import com.google.gwt.dev.javac.JdtCompiler.CompilationUnitAdapter;
 import com.google.gwt.dev.jdt.FindDeferredBindingSitesVisitor.MessageSendSite;
 import com.google.gwt.dev.jjs.impl.FragmentLoaderCreator;
 import com.google.gwt.dev.util.Empty;
-import com.google.gwt.dev.util.JsniRef;
-import com.google.gwt.dev.util.Memory;
 
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
-import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
 import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
 import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
 
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -48,7 +39,7 @@
  * Provides a reusable front-end based on the JDT compiler that incorporates
  * GWT-specific concepts such as JSNI and deferred binding.
  */
-public class WebModeCompilerFrontEnd extends AbstractCompiler {
+public class WebModeCompilerFrontEnd extends BasicWebModeCompiler {
 
   public static CompilationUnitDeclaration[] getCompilationUnitDeclarations(
       TreeLogger logger, String[] seedTypeNames,
@@ -70,72 +61,12 @@
    */
   private WebModeCompilerFrontEnd(CompilationState compilationState,
       RebindPermutationOracle rebindPermOracle) {
-    super(compilationState, false);
+    super(compilationState);
     this.rebindPermOracle = rebindPermOracle;
     this.fragmentLoaderCreator = new FragmentLoaderCreator(
         rebindPermOracle.getGeneratorContext());
   }
 
-  /**
-   * Build the initial set of compilation units.
-   */
-  public CompilationUnitDeclaration[] getCompilationUnitDeclarations(
-      TreeLogger logger, String[] seedTypeNames)
-      throws UnableToCompleteException {
-
-    TypeOracle oracle = compilationState.getTypeOracle();
-    Set<JClassType> intfTypes = oracle.getSingleJsoImplInterfaces();
-    Map<String, CompiledClass> classMapBySource = compilationState.getClassFileMapBySource();
-
-    /*
-     * The alreadyAdded set prevents duplicate CompilationUnits from being added
-     * to the icu list in the case of multiple JSO implementations as inner
-     * classes in the same top-level class or seed classes as SingleJsoImpls
-     * (e.g. JSO itself as the SingleImpl for all tag interfaces).
-     */
-    Set<CompilationUnit> alreadyAdded = new HashSet<CompilationUnit>();
-
-    List<ICompilationUnit> icus = new ArrayList<ICompilationUnit>(
-        seedTypeNames.length + intfTypes.size());
-
-    for (String seedTypeName : seedTypeNames) {
-      CompilationUnit unit = getUnitForType(logger, classMapBySource,
-          seedTypeName);
-
-      if (alreadyAdded.add(unit)) {
-        icus.add(new CompilationUnitAdapter(unit));
-      } else {
-        logger.log(TreeLogger.WARN, "Duplicate compilation unit '"
-            + unit.getDisplayLocation() + "'in seed types");
-      }
-    }
-
-    /*
-     * Add all SingleJsoImpl types that we know about. It's likely that the
-     * concrete types are never explicitly referenced from the seed types.
-     */
-    for (JClassType intf : intfTypes) {
-      String implName = oracle.getSingleJsoImpl(intf).getQualifiedSourceName();
-      CompilationUnit unit = getUnitForType(logger, classMapBySource, implName);
-
-      if (alreadyAdded.add(unit)) {
-        icus.add(new CompilationUnitAdapter(unit));
-        logger.log(TreeLogger.SPAM, "Forced compilation of unit '"
-            + unit.getDisplayLocation()
-            + "' becasue it contains a SingleJsoImpl type");
-      }
-    }
-
-    /*
-     * Compile, which will pull in everything else via
-     * doFindAdditionalTypesUsingMagic()
-     */
-    CompilationUnitDeclaration[] cuds = compile(logger,
-        icus.toArray(new ICompilationUnit[icus.size()]));
-    Memory.maybeDumpMemory("WebModeCompiler");
-    return cuds;
-  }
-
   @Override
   protected void doCompilationUnitDeclarationValidation(
       CompilationUnitDeclaration cud, TreeLogger logger) {
@@ -154,26 +85,6 @@
   }
 
   /**
-   * Pull in types referenced only via JSNI.
-   */
-  @Override
-  protected String[] doFindAdditionalTypesUsingJsni(TreeLogger logger,
-      CompilationUnitDeclaration cud) {
-    FindJsniRefVisitor v = new FindJsniRefVisitor();
-    cud.traverse(v, cud.scope);
-    Set<String> jsniRefs = v.getJsniRefs();
-    Set<String> dependentTypeNames = new HashSet<String>();
-    for (String jsniRef : jsniRefs) {
-      JsniRef parsed = JsniRef.parse(jsniRef);
-      if (parsed != null) {
-        // If we fail to parse, don't add a class reference.
-        dependentTypeNames.add(parsed.className());
-      }
-    }
-    return dependentTypeNames.toArray(Empty.STRINGS);
-  }
-
-  /**
    * Pull in types implicitly referenced through rebind answers.
    */
   @Override
@@ -291,23 +202,4 @@
       return;
     }
   }
-
-  /**
-   * Get the CompilationUnit for a named type or throw an
-   * UnableToCompleteException.
-   */
-  private CompilationUnit getUnitForType(TreeLogger logger,
-      Map<String, CompiledClass> classMapBySource, String typeName)
-      throws UnableToCompleteException {
-
-    CompiledClass compiledClass = classMapBySource.get(typeName);
-    if (compiledClass == null) {
-      logger.log(TreeLogger.ERROR, "Unable to find compilation unit for type '"
-          + typeName + "'");
-      throw new UnableToCompleteException();
-    }
-
-    assert compiledClass.getUnit() != null;
-    return compiledClass.getUnit();
-  }
 }
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 02b1199..538823d 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
@@ -615,7 +615,7 @@
     return didChange;
   }
 
-  private static void checkForErrors(TreeLogger logger,
+  static void checkForErrors(TreeLogger logger,
       CompilationUnitDeclaration[] cuds, boolean itemizeErrors)
       throws UnableToCompleteException {
     boolean compilationFailed = false;
diff --git a/dev/core/test/com/google/gwt/dev/javac/impl/JavaResourceBase.java b/dev/core/test/com/google/gwt/dev/javac/impl/JavaResourceBase.java
index 1eaede2..1da0628 100644
--- a/dev/core/test/com/google/gwt/dev/javac/impl/JavaResourceBase.java
+++ b/dev/core/test/com/google/gwt/dev/javac/impl/JavaResourceBase.java
@@ -95,6 +95,7 @@
       code.append("public class Object {\n");
       code.append("  public String toString() { return \"Object\"; }\n");
       code.append("  public Object clone() { return this; } ");
+      code.append("  public Class getClass() { return Object.class; } ");
       code.append("}\n");
       return code;
     }
diff --git a/dev/core/test/com/google/gwt/dev/javac/impl/MockJavaResource.java b/dev/core/test/com/google/gwt/dev/javac/impl/MockJavaResource.java
index 2f3de7a..3b003e7 100644
--- a/dev/core/test/com/google/gwt/dev/javac/impl/MockJavaResource.java
+++ b/dev/core/test/com/google/gwt/dev/javac/impl/MockJavaResource.java
@@ -17,7 +17,14 @@
 
 public abstract class MockJavaResource extends MockResource {
 
+  private final String qualifiedTypeName;
+
   public MockJavaResource(String qualifiedTypeName) {
     super(Shared.toPath(qualifiedTypeName));
+    this.qualifiedTypeName = qualifiedTypeName;
+  }
+
+  public String getTypeName() {
+    return qualifiedTypeName;
   }
 }
diff --git a/dev/core/test/com/google/gwt/dev/javac/impl/MockResourceOracle.java b/dev/core/test/com/google/gwt/dev/javac/impl/MockResourceOracle.java
index 22383fe..a280b1b 100644
--- a/dev/core/test/com/google/gwt/dev/javac/impl/MockResourceOracle.java
+++ b/dev/core/test/com/google/gwt/dev/javac/impl/MockResourceOracle.java
@@ -48,6 +48,14 @@
     export(newMap);
   }
 
+  public void addOrReplace(Resource... resources) {
+    Map<String, Resource> newMap = new HashMap<String, Resource>(exportedMap);
+    for (Resource resource : resources) {
+      newMap.put(resource.getPath(), resource);
+    }
+    export(newMap);
+  }
+
   public void clear() {
   }
 
diff --git a/dev/core/test/com/google/gwt/dev/jjs/JavaAstConstructor.java b/dev/core/test/com/google/gwt/dev/jjs/JavaAstConstructor.java
new file mode 100644
index 0000000..2684691
--- /dev/null
+++ b/dev/core/test/com/google/gwt/dev/jjs/JavaAstConstructor.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.jjs;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.javac.CompilationState;
+import com.google.gwt.dev.javac.impl.JavaResourceBase;
+import com.google.gwt.dev.javac.impl.MockJavaResource;
+import com.google.gwt.dev.jdt.BasicWebModeCompiler;
+import com.google.gwt.dev.jjs.CorrelationFactory.DummyCorrelationFactory;
+import com.google.gwt.dev.jjs.ast.JDeclaredType;
+import com.google.gwt.dev.jjs.ast.JMethod;
+import com.google.gwt.dev.jjs.ast.JProgram;
+import com.google.gwt.dev.jjs.impl.AssertionNormalizer;
+import com.google.gwt.dev.jjs.impl.BuildTypeMap;
+import com.google.gwt.dev.jjs.impl.FixAssignmentToUnbox;
+import com.google.gwt.dev.jjs.impl.GenerateJavaAST;
+import com.google.gwt.dev.jjs.impl.JavaScriptObjectNormalizer;
+import com.google.gwt.dev.jjs.impl.TypeMap;
+import com.google.gwt.dev.js.ast.JsProgram;
+import com.google.gwt.dev.util.Empty;
+
+import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * Constructs a Java AST for testing.
+ */
+public class JavaAstConstructor {
+
+  public static final MockJavaResource ARRAY = new MockJavaResource(
+      "com.google.gwt.lang.Array") {
+    @Override
+    protected CharSequence getContent() {
+      StringBuffer code = new StringBuffer();
+      code.append("package com.google.gwt.lang;\n");
+      code.append("public final class Array {\n");
+      code.append("}\n");
+      return code;
+    }
+  };
+  public static final MockJavaResource CLASS = new MockJavaResource(
+      "java.lang.Class") {
+    @Override
+    protected CharSequence getContent() {
+      StringBuffer code = new StringBuffer();
+      code.append("package java.lang;\n");
+      code.append("import com.google.gwt.core.client.JavaScriptObject;\n");
+      code.append("public final class Class<T> {\n");
+      code.append("  static <T> Class<T> createForArray(String packageName, String className, String seedName, Class<?> componentType) { return new Class<T>(); }\n");
+      code.append("  static <T> Class<T> createForClass(String packageName, String className, String seedName, Class<? super T> superclass) { return new Class<T>(); }\n");
+      code.append("  static <T> Class<T> createForEnum(String packageName, String className, String seedName, Class<? super T> superclass, JavaScriptObject enumConstantsFunc) { return new Class<T>(); }\n");
+      code.append("  static <T> Class<T> createForInterface(String packageName, String className) { return new Class<T>(); }\n");
+      code.append("  static boolean isClassMetadataEnabled() { return true; }\n");
+      code.append("  public boolean desiredAssertionStatus() { return true; }\n");
+      code.append("}\n");
+      return code;
+    }
+  };
+  public static final MockJavaResource CLASSLITERALHOLDER = new MockJavaResource(
+      "com.google.gwt.lang.ClassLiteralHolder") {
+    @Override
+    protected CharSequence getContent() {
+      StringBuffer code = new StringBuffer();
+      code.append("package com.google.gwt.lang;\n");
+      code.append("final class ClassLiteralHolder {\n");
+      code.append("}\n");
+      return code;
+    }
+  };
+  public static final MockJavaResource GWT = new MockJavaResource(
+      "com.google.gwt.core.client.GWT") {
+    @Override
+    protected CharSequence getContent() {
+      StringBuffer code = new StringBuffer();
+      code.append("package com.google.gwt.core.client;\n");
+      code.append("public final class GWT {\n");
+      code.append("  public boolean isClient() { return true; };\n");
+      code.append("  public boolean isScript() { return true; };\n");
+      code.append("}\n");
+      return code;
+    }
+  };
+  public static final MockJavaResource STATS = new MockJavaResource(
+      "com.google.gwt.lang.Stats") {
+    @Override
+    protected CharSequence getContent() {
+      StringBuffer code = new StringBuffer();
+      code.append("package com.google.gwt.lang;\n");
+      code.append("public class Stats {\n");
+      code.append("  public boolean isStatsAvailable() { return false; };\n");
+      code.append("}\n");
+      return code;
+    }
+  };
+
+  public static JProgram construct(TreeLogger logger, CompilationState state,
+      String... entryPoints) throws UnableToCompleteException {
+
+    Set<String> allRootTypes = new TreeSet<String>(Arrays.asList(entryPoints));
+    for (MockJavaResource resource : getCompilerTypes()) {
+      allRootTypes.add(resource.getTypeName());
+    }
+
+    CompilationUnitDeclaration[] goldenCuds = BasicWebModeCompiler.getCompilationUnitDeclarations(
+        logger, state, allRootTypes.toArray(Empty.STRINGS));
+
+    // Check for compilation problems. We don't log here because any problems
+    // found here will have already been logged by AbstractCompiler.
+    //
+    JavaToJavaScriptCompiler.checkForErrors(logger, goldenCuds, false);
+
+    CorrelationFactory correlator = new DummyCorrelationFactory();
+    JProgram jprogram = new JProgram(correlator);
+    JsProgram jsProgram = new JsProgram(correlator);
+
+    /*
+     * (1) Build a flattened map of TypeDeclarations => JType. The resulting map
+     * contains entries for all reference types. BuildTypeMap also parses all
+     * JSNI.
+     */
+    TypeMap typeMap = new TypeMap(jprogram);
+    TypeDeclaration[] allTypeDeclarations = BuildTypeMap.exec(typeMap,
+        goldenCuds, jsProgram);
+
+    // BuildTypeMap can uncover syntactic JSNI errors; report & abort
+    JavaToJavaScriptCompiler.checkForErrors(logger, goldenCuds, true);
+
+    // Compute all super type/sub type info
+    jprogram.typeOracle.computeBeforeAST();
+
+    // (2) Create our own Java AST from the JDT AST.
+    JJSOptionsImpl options = new JJSOptionsImpl();
+    options.setEnableAssertions(true);
+    GenerateJavaAST.exec(allTypeDeclarations, typeMap, jprogram, jsProgram,
+        options);
+
+    // GenerateJavaAST can uncover semantic JSNI errors; report & abort
+    JavaToJavaScriptCompiler.checkForErrors(logger, goldenCuds, true);
+
+    // (3) Perform Java AST normalizations.
+    FixAssignmentToUnbox.exec(jprogram);
+    // Turn into assertion checking calls.
+    AssertionNormalizer.exec(jprogram);
+
+    // Add entry methods for entry points.
+    for (String entryPoint : entryPoints) {
+      JDeclaredType entryType = jprogram.getFromTypeMap(entryPoint);
+      for (JMethod method : entryType.getMethods()) {
+        if (method.isStatic() && JProgram.isClinit(method)) {
+          jprogram.addEntryMethod(method);
+        }
+      }
+    }
+    // Replace references to JSO subtypes with JSO itself.
+    JavaScriptObjectNormalizer.exec(jprogram);
+
+    // Tree is now ready to optimize.
+    return jprogram;
+  }
+
+  public static MockJavaResource[] getCompilerTypes() {
+    List<MockJavaResource> result = new ArrayList<MockJavaResource>();
+    Collections.addAll(result, JavaResourceBase.getStandardResources());
+    // Replace the basic Class with a compiler-specific one.
+    result.remove(JavaResourceBase.CLASS);
+    Collections.addAll(result, ARRAY, CLASS, CLASSLITERALHOLDER, GWT);
+    return result.toArray(new MockJavaResource[result.size()]);
+  }
+}
diff --git a/dev/core/test/com/google/gwt/dev/jjs/impl/ControlFlowAnalyzerTest.java b/dev/core/test/com/google/gwt/dev/jjs/impl/ControlFlowAnalyzerTest.java
new file mode 100644
index 0000000..c02e02b
--- /dev/null
+++ b/dev/core/test/com/google/gwt/dev/jjs/impl/ControlFlowAnalyzerTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.jjs.impl;
+
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.javac.impl.MockJavaResource;
+import com.google.gwt.dev.jjs.ast.JDeclaredType;
+import com.google.gwt.dev.jjs.ast.JField;
+import com.google.gwt.dev.jjs.ast.JProgram;
+import com.google.gwt.dev.util.Empty;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Tests {@link ControlFlowAnalyzer}.
+ */
+public class ControlFlowAnalyzerTest extends OptimizerTestBase {
+
+  /**
+   * Answers predicates about an analyzed program.
+   */
+  private static final class Result {
+    private final ControlFlowAnalyzer cfa;
+    private final JProgram program;
+
+    public Result(JProgram program, ControlFlowAnalyzer cfa) {
+      this.program = program;
+      this.cfa = cfa;
+    }
+
+    public void assertOnlyFieldsWritten(String... expectedFields) {
+      Set<JField> expectedSet = new HashSet<JField>();
+      for (String expectedField : expectedFields) {
+        JField field = findField(program, expectedField);
+        assertNotNull(field);
+        expectedSet.add(field);
+      }
+      assertEquals(expectedSet, cfa.getFieldsWritten());
+    }
+
+    public void assertOnlyInstantiatedTypes(String... expectedTypes) {
+      Set<JDeclaredType> expectedSet = new HashSet<JDeclaredType>();
+      for (String expectedType : expectedTypes) {
+        JDeclaredType type = findType(program, expectedType);
+        assertNotNull(type);
+        expectedSet.add(type);
+      }
+      assertEquals(expectedSet, cfa.getInstantiatedTypes());
+    }
+
+    public void assertOnlyLiveStrings(String... expectedStrings) {
+      Set<String> expectedSet = new HashSet<String>();
+      Collections.addAll(expectedSet, expectedStrings);
+      cfa.getLiveStrings();
+      assertEquals(expectedSet, cfa.getLiveStrings());
+    }
+  }
+
+  /**
+   * Tests properties of an empty program.
+   */
+  public void testEmpty() throws Exception {
+    Result result = analyzeSnippet("");
+    result.assertOnlyFieldsWritten(Empty.STRINGS);
+    result.assertOnlyInstantiatedTypes(Empty.STRINGS);
+    result.assertOnlyLiveStrings(Empty.STRINGS);
+  }
+
+  /**
+   * Tests that the JavaScriptObject type gets rescued in the three specific
+   * circumstances where values can pass from JS into Java.
+   */
+  public void testRescueJavaScriptObjectFromJsni() throws Exception {
+    sourceOracle.addOrReplace(new MockJavaResource("test.Foo") {
+      @Override
+      protected CharSequence getContent() {
+        StringBuffer code = new StringBuffer();
+        code.append("package test;\n");
+        code.append("import com.google.gwt.core.client.JavaScriptObject;\n");
+        code.append("public class Foo {\n");
+        code.append("  public static native JavaScriptObject returnsJso() /*-{ return {}; }-*/;\n");
+        code.append("  public static native void assignsJsoField() /*-{ @test.Foo::jsoField = {}; }-*/;\n");
+        code.append("  public static native void readsJsoField() /*-{ var x = @test.Foo::jsoField; }-*/;\n");
+        code.append("  public static native void passesJsoParam() /*-{ @test.Foo::calledFromJsni(Lcom/google/gwt/core/client/JavaScriptObject;)({}); }-*/;\n");
+        code.append("  private static JavaScriptObject jsoField = null;\n");
+        code.append("  private static void calledFromJsni(JavaScriptObject arg) { }\n");
+        code.append("}\n");
+        return code;
+      }
+    });
+    addSnippetImport("test.Foo");
+
+    analyzeSnippet("").assertOnlyInstantiatedTypes(Empty.STRINGS);
+
+    // Returning a JSO from a JSNI method rescues.
+    analyzeSnippet("Foo.returnsJso();").assertOnlyInstantiatedTypes(
+        "JavaScriptObject", "Object");
+
+    // Assigning into a JSO field from a JSNI method rescues.
+    analyzeSnippet("Foo.assignsJsoField();").assertOnlyInstantiatedTypes(
+        "JavaScriptObject", "Object");
+
+    // Passing from Java to JS via a JSNI field read should NOT rescue.
+    analyzeSnippet("Foo.readsJsoField();").assertOnlyInstantiatedTypes(
+        Empty.STRINGS);
+
+    // Passing a parameter from JS to Java rescues.
+    analyzeSnippet("Foo.passesJsoParam();").assertOnlyInstantiatedTypes(
+        "JavaScriptObject", "Object");
+  }
+
+  private Result analyzeSnippet(String codeSnippet)
+      throws UnableToCompleteException {
+    JProgram program = compileSnippet("void", codeSnippet);
+    ControlFlowAnalyzer cfa = new ControlFlowAnalyzer(program);
+    cfa.traverseFrom(findMainMethod(program));
+    return new Result(program, cfa);
+  }
+}
diff --git a/dev/core/test/com/google/gwt/dev/jjs/impl/DeadCodeEliminationTest.java b/dev/core/test/com/google/gwt/dev/jjs/impl/DeadCodeEliminationTest.java
new file mode 100644
index 0000000..b26f401
--- /dev/null
+++ b/dev/core/test/com/google/gwt/dev/jjs/impl/DeadCodeEliminationTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.jjs.impl;
+
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.jjs.ast.JProgram;
+
+/**
+ * Tests {@link DeadCodeElimination}.
+ */
+public class DeadCodeEliminationTest extends OptimizerTestBase {
+
+  private final class Result {
+    private final String optimized;
+    private final String returnType;
+    private final String userCode;
+
+    public Result(String returnType, String userCode, String optimized) {
+      this.returnType = returnType;
+      this.userCode = userCode;
+      this.optimized = optimized;
+    }
+
+    public void into(String expected) throws UnableToCompleteException {
+      JProgram program = compileSnippet(returnType, expected);
+      expected = getMainMethodSource(program);
+      assertEquals(userCode, expected, optimized);
+    }
+  }
+
+  public void testConditionalOptimizations() throws Exception {
+    optimize("int", "return true ? 3 : 4;").into("return 3;");
+    optimize("int", "return false ? 3 : 4;").into("return 4;");
+
+    addSnippetClassDecl("static volatile boolean TEST");
+    addSnippetClassDecl("static volatile boolean RESULT");
+
+    optimize("boolean", "return TEST ? true : RESULT;").into(
+        "return TEST || RESULT;");
+
+    optimize("boolean", "return TEST ? false : RESULT;").into(
+        "return !TEST && RESULT;");
+
+    optimize("boolean", "return TEST ? RESULT : true;").into(
+        "return !TEST || RESULT;");
+
+    optimize("boolean", "return TEST ? RESULT : false;").into(
+        "return TEST && RESULT;");
+  }
+
+  public void testIfOptimizations() throws Exception {
+    optimize("int", "if (true) return 1; return 0;").into("return 1;");
+    optimize("int", "if (false) return 1; return 0;").into("return 0;");
+    optimize("int", "if (true) return 1; else return 2;").into("return 1;");
+    optimize("int", "if (false) return 1; else return 2;").into("return 2;");
+
+    optimize("int", "if (true) {} else return 4; return 0;").into("return 0;");
+
+    addSnippetClassDecl("static volatile boolean TEST");
+    addSnippetClassDecl("static boolean test() { return TEST; }");
+    optimize("int", "if (test()) {} else {}; return 0;").into(
+        "test(); return 0;");
+  }
+
+  private Result optimize(final String returnType, final String codeSnippet)
+      throws UnableToCompleteException {
+    JProgram program = compileSnippet(returnType, codeSnippet);
+    DeadCodeElimination.exec(program);
+    return new Result(returnType, codeSnippet, getMainMethodSource(program));
+  }
+}
diff --git a/dev/core/test/com/google/gwt/dev/jjs/impl/ExpressionAnalyzerTest.java b/dev/core/test/com/google/gwt/dev/jjs/impl/ExpressionAnalyzerTest.java
new file mode 100644
index 0000000..47bc7b3
--- /dev/null
+++ b/dev/core/test/com/google/gwt/dev/jjs/impl/ExpressionAnalyzerTest.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.jjs.impl;
+
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.javac.impl.MockJavaResource;
+import com.google.gwt.dev.jjs.ast.JMethod;
+import com.google.gwt.dev.jjs.ast.JMethodBody;
+import com.google.gwt.dev.jjs.ast.JProgram;
+import com.google.gwt.dev.jjs.ast.JReturnStatement;
+
+/**
+ * Tests {@link ExpressionAnalyzer}.
+ */
+public class ExpressionAnalyzerTest extends OptimizerTestBase {
+
+  private static class Result {
+    private final ExpressionAnalyzer ea;
+    private boolean accessesField;
+    private boolean accessesFieldNonFinal;
+    private boolean accessesLocal;
+    private boolean accessesParameter;
+    private boolean canThrowException;
+    private boolean createsObject;
+    private boolean hasAssignment;
+    private boolean hasAssignmentToField;
+    private boolean hasAssignmentToLocal;
+    private boolean hasAssignmentToParameter;
+
+    public Result(ExpressionAnalyzer ea) {
+      this.ea = ea;
+    }
+
+    public Result accessesField() {
+      accessesField = true;
+      return this;
+    }
+
+    public Result accessesFieldNonFinal() {
+      accessesField = true;
+      accessesFieldNonFinal = true;
+      return this;
+    }
+
+    public Result accessesLocal() {
+      accessesLocal = true;
+      return this;
+    }
+
+    public Result accessesParameter() {
+      accessesParameter = true;
+      return this;
+    }
+
+    public Result canThrowException() {
+      canThrowException = true;
+      return this;
+    }
+
+    public Result createsObject() {
+      createsObject = true;
+      return this;
+    }
+
+    public Result hasAssignment() {
+      hasAssignment = true;
+      return this;
+    }
+
+    public Result hasAssignmentToField() {
+      hasAssignment = true;
+      hasAssignmentToField = true;
+      return this;
+    }
+
+    public Result hasAssignmentToLocal() {
+      hasAssignment = true;
+      hasAssignmentToLocal = true;
+      return this;
+    }
+
+    public Result hasAssignmentToParameter() {
+      hasAssignment = true;
+      hasAssignmentToParameter = true;
+      return this;
+    }
+
+    public void check() {
+      assertEquals(accessesField, ea.accessesField());
+      assertEquals(accessesFieldNonFinal, ea.accessesFieldNonFinal());
+      assertEquals(accessesLocal, ea.accessesLocal());
+      assertEquals(accessesParameter, ea.accessesParameter());
+      assertEquals(canThrowException, ea.canThrowException());
+      assertEquals(createsObject, ea.createsObject());
+      assertEquals(hasAssignment, ea.hasAssignment());
+      assertEquals(hasAssignmentToField, ea.hasAssignmentToField());
+      assertEquals(hasAssignmentToLocal, ea.hasAssignmentToLocal());
+      assertEquals(hasAssignmentToParameter, ea.hasAssignmentToParameter());
+    }
+  }
+
+  public void testEmpty() throws Exception {
+    analyzeExpression("int", "0").check();
+  }
+
+  public void testFieldAccessInstance() throws Exception {
+    sourceOracle.addOrReplace(new MockJavaResource("test.Foo") {
+      @Override
+      protected CharSequence getContent() {
+        StringBuffer code = new StringBuffer();
+        code.append("package test;\n");
+        code.append("import com.google.gwt.core.client.JavaScriptObject;\n");
+        code.append("public class Foo {\n");
+        code.append("  public final boolean BOOL_CONST = true;\n");
+        code.append("  public boolean FOO = true;\n");
+        code.append("}\n");
+        return code;
+      }
+    });
+    addSnippetImport("test.Foo");
+    addSnippetClassDecl("static final Foo f = new Foo();");
+
+    analyzeExpression("boolean", "f.BOOL_CONST").accessesField().canThrowException().check();
+
+    analyzeExpression("boolean", "f.FOO").accessesFieldNonFinal().canThrowException().check();
+
+    analyzeExpression("boolean", "f.FOO = false").accessesFieldNonFinal().canThrowException().hasAssignment().hasAssignmentToField().check();
+  }
+
+  public void testFieldAccessStatic() throws Exception {
+    addSnippetClassDecl("static boolean trueMethod() { return true; }");
+    addSnippetClassDecl("static final boolean BOOL_CONST = trueMethod();");
+    addSnippetClassDecl("static volatile boolean FOO;");
+
+    analyzeExpression("boolean", "BOOL_CONST").accessesField().check();
+
+    analyzeExpression("boolean", "FOO").accessesFieldNonFinal().check();
+
+    analyzeExpression("boolean", "FOO = false").accessesFieldNonFinal().hasAssignmentToField().check();
+  }
+
+  private Result analyzeExpression(String type, String expression)
+      throws UnableToCompleteException {
+    JProgram program = compileSnippet(type, "return " + expression + ";");
+    ExpressionAnalyzer ea = new ExpressionAnalyzer();
+    JMethod mainMethod = findMainMethod(program);
+    JMethodBody body = (JMethodBody) mainMethod.getBody();
+    JReturnStatement returnStmt = (JReturnStatement) body.getStatements().get(0);
+    ea.accept(returnStmt.getExpr());
+    return new Result(ea);
+  }
+}
diff --git a/dev/core/test/com/google/gwt/dev/jjs/impl/OptimizerTestBase.java b/dev/core/test/com/google/gwt/dev/jjs/impl/OptimizerTestBase.java
new file mode 100644
index 0000000..9ef05dc
--- /dev/null
+++ b/dev/core/test/com/google/gwt/dev/jjs/impl/OptimizerTestBase.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.jjs.impl;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.javac.CompilationState;
+import com.google.gwt.dev.javac.impl.MockJavaResource;
+import com.google.gwt.dev.javac.impl.MockResourceOracle;
+import com.google.gwt.dev.jjs.JavaAstConstructor;
+import com.google.gwt.dev.jjs.ast.JDeclaredType;
+import com.google.gwt.dev.jjs.ast.JField;
+import com.google.gwt.dev.jjs.ast.JMethod;
+import com.google.gwt.dev.jjs.ast.JProgram;
+import com.google.gwt.dev.util.log.AbstractTreeLogger;
+import com.google.gwt.dev.util.log.PrintWriterTreeLogger;
+
+import junit.framework.TestCase;
+
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * Tests {@link DeadCodeElimination}.
+ */
+public abstract class OptimizerTestBase extends TestCase {
+
+  /**
+   * Finds a field with a type.
+   */
+  public static JField findField(JDeclaredType type, String fieldName) {
+    for (JField field : type.getFields()) {
+      if (field.getName().equals(fieldName)) {
+        return field;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Finds a field by name, e.g. <code>Foo.field</code>.
+   */
+  public static JField findField(JProgram program, String qualifiedFieldName) {
+    int pos = qualifiedFieldName.lastIndexOf('.');
+    assertTrue(pos > 0);
+    String typeName = qualifiedFieldName.substring(0, pos);
+    String fieldName = qualifiedFieldName.substring(pos + 1);
+    JDeclaredType type = findType(program, typeName);
+    JField field = findField(type, fieldName);
+    return field;
+  }
+
+  public static JMethod findMainMethod(JProgram program) {
+    JDeclaredType mainType = program.getFromTypeMap("test.EntryPoint");
+    JMethod mainMethod = null;
+    for (JMethod method : mainType.getMethods()) {
+      if (method.getName().equals("onModuleLoad")) {
+        mainMethod = method;
+        break;
+      }
+    }
+    return mainMethod;
+  }
+
+  /**
+   * Finds a type by name. The type name may be short, e.g. <code>"Foo"</code>,
+   * or fully-qualified, e.g. <code>"com.google.example.Foo"</code>. If a
+   * short name is used, it must be unambiguous.
+   */
+  public static JDeclaredType findType(JProgram program, String typeName) {
+    JDeclaredType type = program.getFromTypeMap(typeName);
+    if (type == null && typeName.indexOf('.') < 0) {
+      // Do a slow lookup by short name.
+      for (JDeclaredType checkType : program.getDeclaredTypes()) {
+        if (checkType.getShortName().equals(typeName)) {
+          if (type == null) {
+            type = checkType;
+          } else {
+            fail("Ambiguous type reference '" + typeName + "' might be '"
+                + type.getName() + "' or '" + checkType.getName()
+                + "' (possibly more matches)");
+          }
+        }
+      }
+    }
+    return type;
+  }
+
+  public static String getMainMethodSource(JProgram program) {
+    JMethod mainMethod = findMainMethod(program);
+    return mainMethod.getBody().toSource();
+  }
+
+  /**
+   * Tweak this if you want to see the log output.
+   */
+  private static TreeLogger createTreeLogger() {
+    boolean reallyLog = true;
+    if (reallyLog) {
+      AbstractTreeLogger logger = new PrintWriterTreeLogger();
+      logger.setMaxDetail(TreeLogger.WARN);
+      return logger;
+    }
+    return TreeLogger.NULL;
+  }
+
+  protected final MockResourceOracle sourceOracle = new MockResourceOracle();
+
+  private final TreeLogger logger = createTreeLogger();
+
+  private final Set<String> snippetClassDecls = new TreeSet<String>();
+
+  private final Set<String> snippetImports = new TreeSet<String>();
+
+  private final CompilationState state = new CompilationState(logger,
+      sourceOracle);
+
+  public OptimizerTestBase() {
+    sourceOracle.add(JavaAstConstructor.getCompilerTypes());
+  }
+
+  /**
+   * Adds an import statement for any code subsequently passed to
+   * {@link #compileSnippet(String, String)}.
+   */
+  protected void addSnippetImport(String typeName) {
+    snippetImports.add(typeName);
+  }
+
+  /**
+   * Adds a local field declaration for code subsequently passed to
+   * {@link #compileSnippet(String, String)}.
+   */
+  protected void addSnippetClassDecl(String fieldDecl) {
+    snippetClassDecls.add(fieldDecl);
+  }
+
+  /**
+   * Returns the program that results from compiling the specified code snippet
+   * as the body of an entry point method.
+   * 
+   * @param returnType the return type of the method to compile; use "void" if
+   *          the code snippet has no return statement
+   * @param codeSnippet the body of the entry method
+   */
+  protected JProgram compileSnippet(final String returnType,
+      final String codeSnippet) throws UnableToCompleteException {
+    sourceOracle.addOrReplace(new MockJavaResource("test.EntryPoint") {
+      @Override
+      protected CharSequence getContent() {
+        StringBuffer code = new StringBuffer();
+        code.append("package test;\n");
+        for (String snippetImport : snippetImports) {
+          code.append("import " + snippetImport + ";\n");
+        }
+        code.append("public class EntryPoint {\n");
+        for (String snippetClassDecl : snippetClassDecls) {
+          code.append(snippetClassDecl + ";\n");
+        }
+        code.append("  public static " + returnType + " onModuleLoad() {\n");
+        code.append(codeSnippet);
+        code.append("  }\n");
+        code.append("}\n");
+        return code;
+      }
+    });
+    state.refresh(logger);
+
+    JProgram program = JavaAstConstructor.construct(logger, state,
+        "test.EntryPoint");
+    return program;
+  }
+}