diff --git a/dev/core/src/com/google/gwt/dev/jjs/ast/js/JsonObject.java b/dev/core/src/com/google/gwt/dev/jjs/ast/js/JsonObject.java
index a776064..8602bc0 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/ast/js/JsonObject.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/ast/js/JsonObject.java
@@ -16,6 +16,7 @@
 package com.google.gwt.dev.jjs.ast.js;
 
 import com.google.gwt.dev.jjs.ast.Context;
+import com.google.gwt.dev.jjs.ast.JClassType;
 import com.google.gwt.dev.jjs.ast.JExpression;
 import com.google.gwt.dev.jjs.ast.JNode;
 import com.google.gwt.dev.jjs.ast.JProgram;
@@ -54,19 +55,20 @@
     }
   }
 
-  public final List/* <JsonPropInit> */propInits = new ArrayList/* <JsonPropInit> */();
+  public final List<JsonPropInit> propInits = new ArrayList<JsonPropInit>();
 
   public JsonObject(JProgram program) {
     super(program, null);
   }
 
   public JType getType() {
-    return program.getTypeVoid();
+    // If JavaScriptObject type is not available, just return the Object type
+    JClassType jsoType = program.getJavaScriptObject();
+    return (jsoType != null) ? jsoType : program.getTypeJavaLangObject();
   }
 
   public boolean hasSideEffects() {
-    for (int i = 0, c = propInits.size(); i < c; ++i) {
-      JsonPropInit propInit = ((JsonPropInit) propInits.get(i));
+    for (JsonPropInit propInit : propInits) {
       if (propInit.labelExpr.hasSideEffects()
           || propInit.valueExpr.hasSideEffects()) {
         return true;
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/BuildTypeMap.java b/dev/core/src/com/google/gwt/dev/jjs/impl/BuildTypeMap.java
index 51258e9..93873ad 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/BuildTypeMap.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/BuildTypeMap.java
@@ -27,7 +27,6 @@
 import com.google.gwt.dev.jjs.ast.JParameter;
 import com.google.gwt.dev.jjs.ast.JProgram;
 import com.google.gwt.dev.jjs.ast.JReferenceType;
-import com.google.gwt.dev.jjs.ast.JReturnStatement;
 import com.google.gwt.dev.jjs.ast.JType;
 import com.google.gwt.dev.jjs.ast.js.JsniMethodBody;
 import com.google.gwt.dev.js.JsParser;
@@ -41,9 +40,11 @@
 import org.eclipse.jdt.internal.compiler.ASTVisitor;
 import org.eclipse.jdt.internal.compiler.CompilationResult;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
 import org.eclipse.jdt.internal.compiler.ast.Argument;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.Expression;
 import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
@@ -181,6 +182,14 @@
             false);
         mapThrownExceptions(newMethod, b);
 
+        // Enums have hidden arguments for name and value
+        if (enclosingType instanceof JEnumType) {
+          program.createParameter(info, "enum$name".toCharArray(),
+              program.getTypeJavaLangString(), true, newMethod);
+          program.createParameter(info, "enum$ordinal".toCharArray(),
+              program.getTypePrimitiveInt(), true, newMethod);
+        }
+
         // user args
         mapParameters(newMethod, ctorDecl);
         // original params are now frozen
@@ -231,8 +240,14 @@
         FieldBinding b = fieldDeclaration.binding;
         SourceInfo info = makeSourceInfo(fieldDeclaration);
         JReferenceType enclosingType = (JReferenceType) typeMap.get(scope.enclosingSourceType());
-        createField(info, b, enclosingType,
-            fieldDeclaration.initialization != null);
+        Expression initialization = fieldDeclaration.initialization;
+        if (initialization != null
+            && initialization instanceof AllocationExpression
+            && ((AllocationExpression) initialization).enumConstant != null) {
+          createEnumField(info, b, enclosingType);
+        } else {
+          createField(info, b, enclosingType, initialization != null);
+        }
         return true;
       } catch (Throwable e) {
         throw translateException(fieldDeclaration, e);
@@ -290,17 +305,20 @@
       return process(typeDeclaration);
     }
 
+    private JField createEnumField(SourceInfo info, FieldBinding binding,
+        JReferenceType enclosingType) {
+      JType type = (JType) typeMap.get(binding.type);
+      JField field = program.createEnumField(info, binding.name,
+          (JEnumType) enclosingType, (JClassType) type, binding.original().id);
+      typeMap.put(binding, field);
+      return field;
+    }
+
     private JField createField(SourceInfo info, FieldBinding binding,
         JReferenceType enclosingType, boolean hasInitializer) {
       JType type = (JType) typeMap.get(binding.type);
-      JField field;
-      if (binding.declaringClass.isEnum()) {
-        field = program.createEnumField(info, binding.name,
-            (JEnumType) enclosingType, (JClassType) type, binding.original().id);
-      } else {
-        field = program.createField(info, binding.name, enclosingType, type,
-            binding.isStatic(), binding.isFinal(), hasInitializer);
-      }
+      JField field = program.createField(info, binding.name, enclosingType,
+          type, binding.isStatic(), binding.isFinal(), hasInitializer);
       typeMap.put(binding, field);
       return field;
     }
@@ -400,7 +418,7 @@
       currentFileName = String.valueOf(compResult.fileName);
       SourceTypeBinding binding = typeDeclaration.binding;
       if (binding.isAnnotationType()) {
-        // TODO
+        // Ignore these.
         return false;
       }
       if (binding.constantPoolName() == null) {
@@ -448,10 +466,12 @@
           JInterfaceType superInterface = (JInterfaceType) typeMap.get(superInterfaceBinding);
           type.implments.add(superInterface);
         }
-        typeDecls.add(typeDeclaration);
+
         if (binding.isEnum()) {
-          processEnum(binding, type);
+          processEnumType(binding, (JEnumType) type);
         }
+
+        typeDecls.add(typeDeclaration);
         return true;
       } catch (InternalCompilerException ice) {
         ice.addNode(type);
@@ -461,7 +481,7 @@
       }
     }
 
-    private void processEnum(SourceTypeBinding binding, JReferenceType type) {
+    private void processEnumType(SourceTypeBinding binding, JEnumType type) {
       // Visit the synthetic values() and valueOf() methods.
       for (MethodBinding methodBinding : binding.methods) {
         if (methodBinding instanceof SyntheticMethodBinding) {
@@ -469,22 +489,15 @@
           TypeBinding[] parameters = methodBinding.parameters;
           if (parameters.length == 0) {
             assert newMethod.getName().equals("values");
-            // TODO: hack
-            JMethodBody body = (JMethodBody) newMethod.getBody();
-            body.getStatements().add(
-                new JReturnStatement(program, null, program.getLiteralNull()));
           } else if (parameters.length == 1) {
             assert newMethod.getName().equals("valueOf");
             assert typeMap.get(parameters[0]) == program.getTypeJavaLangString();
             program.createParameter(null, "name".toCharArray(),
                 program.getTypeJavaLangString(), true, newMethod);
-            // TODO: hack
-            JMethodBody body = (JMethodBody) newMethod.getBody();
-            body.getStatements().add(
-                new JReturnStatement(program, null, program.getLiteralNull()));
           } else {
             assert false;
           }
+          newMethod.freezeParamTypes();
         }
       }
     }
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java
index 0119aff..e80bdac 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java
@@ -37,6 +37,7 @@
 import com.google.gwt.dev.jjs.ast.JDoStatement;
 import com.google.gwt.dev.jjs.ast.JDoubleLiteral;
 import com.google.gwt.dev.jjs.ast.JEnumField;
+import com.google.gwt.dev.jjs.ast.JEnumType;
 import com.google.gwt.dev.jjs.ast.JExpression;
 import com.google.gwt.dev.jjs.ast.JExpressionStatement;
 import com.google.gwt.dev.jjs.ast.JField;
@@ -80,6 +81,7 @@
 import com.google.gwt.dev.jjs.ast.js.JsniFieldRef;
 import com.google.gwt.dev.jjs.ast.js.JsniMethodBody;
 import com.google.gwt.dev.jjs.ast.js.JsniMethodRef;
+import com.google.gwt.dev.jjs.ast.js.JsonObject;
 import com.google.gwt.dev.js.ast.JsContext;
 import com.google.gwt.dev.js.ast.JsExpression;
 import com.google.gwt.dev.js.ast.JsFunction;
@@ -260,14 +262,42 @@
       program = this.typeMap.getProgram();
     }
 
+    public void processEnumType(JEnumType type) {
+      // Create a JSNI map for string-based lookup.
+      JField mapField = createEnumValueMap(type);
+
+      // Generate the synthetic values() and valueOf() methods.
+      for (JMethod method : type.methods) {
+        currentMethod = method;
+        if ("values".equals(method.getName())) {
+          if (method.params.size() != 0) {
+            continue;
+          }
+          currentMethodBody = (JMethodBody) method.getBody();
+          writeEnumValuesMethod(type);
+        } else if ("valueOf".equals(method.getName())) {
+          if (method.params.size() != 1) {
+            continue;
+          }
+          if (method.params.get(0).getType() != program.getTypeJavaLangString()) {
+            continue;
+          }
+          currentMethodBody = (JMethodBody) method.getBody();
+          writeEnumValueOfMethod(type, mapField);
+        }
+        currentMethodBody = null;
+        currentMethod = null;
+      }
+    }
+
     /**
      * We emulate static initializers and instance initializers as methods. As
      * in other cases, this gives us: simpler AST, easier to optimize, more like
      * output JavaScript.
      */
     public void processType(TypeDeclaration x) {
-      if (x.binding.isEnum() || x.binding.isAnnotationType()) {
-        // TODO
+      if (x.binding.isAnnotationType()) {
+        // Do not process.
         return;
       }
       currentClass = (JReferenceType) typeMap.get(x.binding);
@@ -331,6 +361,10 @@
           }
         }
 
+        if (x.binding.isEnum()) {
+          processEnumType((JEnumType) currentClass);
+        }
+
         currentClassScope = null;
         currentClass = null;
         currentSeparatorPositions = null;
@@ -569,6 +603,17 @@
           }
         }
 
+        // Enums: wire up synthetic name/ordinal params to the super method.
+        if (enclosingType instanceof JEnumType) {
+          assert (superOrThisCall != null);
+          JVariableRef enumNameRef = createVariableRef(
+              superOrThisCall.getSourceInfo(), ctor.params.get(0));
+          superOrThisCall.getArgs().add(0, enumNameRef);
+          JVariableRef enumOrdinalRef = createVariableRef(
+              superOrThisCall.getSourceInfo(), ctor.params.get(1));
+          superOrThisCall.getArgs().add(1, enumOrdinalRef);
+        }
+
         // optional this or super constructor call
         if (superOrThisCall != null) {
           statements.add(superOrThisCall.makeStatement());
@@ -658,6 +703,13 @@
         call = new JMethodCall(program, info, newInstance, ctor);
       }
 
+      // Enums: hidden arguments for the name and id.
+      if (x.enumConstant != null) {
+        call.getArgs().add(program.getLiteralString(x.enumConstant.name));
+        call.getArgs().add(
+            program.getLiteralInt(x.enumConstant.binding.original().id));
+      }
+
       // Plain old regular user arguments
       if (x.arguments != null) {
         for (int i = 0, n = x.arguments.length; i < n; ++i) {
@@ -1273,6 +1325,11 @@
           initializer = dispProcessExpression(declaration.initialization);
         }
 
+        if (field instanceof JEnumField) {
+          // An enum field must be initialized!
+          assert (initializer instanceof JMethodCall);
+        }
+
         if (initializer instanceof JLiteral) {
           field.constInitializer = (JLiteral) initializer;
         } else if (initializer != null) {
@@ -1768,7 +1825,7 @@
             String varName = String.valueOf(arg.name);
             JParameter param = null;
             for (int i = 0; i < currentMethod.params.size(); ++i) {
-              JParameter paramIt = (JParameter) currentMethod.params.get(i);
+              JParameter paramIt = currentMethod.params.get(i);
               if (varType == paramIt.getType()
                   && varName.equals(paramIt.getName())) {
                 param = paramIt;
@@ -1879,6 +1936,25 @@
       return call;
     }
 
+    private JField createEnumValueMap(JEnumType type) {
+      JsonObject map = new JsonObject(program);
+      for (JEnumField field : type.enumList) {
+        // JSON maps require leading underscores to prevent collisions.
+        JStringLiteral key = program.getLiteralString("_" + field.getName());
+        JFieldRef value = new JFieldRef(program, null, null, field, type);
+        map.propInits.add(new JsonObject.JsonPropInit(program, key, value));
+      }
+      JField mapField = program.createField(null, "enum$map".toCharArray(),
+          type, map.getType(), true, true, true);
+
+      // Initialize in clinit.
+      JMethodBody clinitBody = (JMethodBody) type.methods.get(0).getBody();
+      JExpressionStatement assignment = program.createAssignmentStmt(null,
+          createVariableRef(null, mapField), map);
+      clinitBody.getStatements().add(assignment);
+      return mapField;
+    }
+
     private JLocalDeclarationStatement createLocalDeclaration(SourceInfo info,
         JLocal arrayVar, JExpression value) {
       return new JLocalDeclarationStatement(program, info, new JLocalRef(
@@ -2309,6 +2385,32 @@
           toUnbox, valueMethod);
       return unboxCall;
     }
+
+    private void writeEnumValueOfMethod(JEnumType type, JField mapField) {
+      // return Enum.valueOf(map, name);
+      JFieldRef mapRef = new JFieldRef(program, null, null, mapField, type);
+      JVariableRef nameRef = createVariableRef(null,
+          currentMethod.params.get(0));
+      JMethod delegateTo = program.getIndexedMethod("Enum.valueOf");
+      JMethodCall call = new JMethodCall(program, null, null, delegateTo);
+      call.getArgs().add(mapRef);
+      call.getArgs().add(nameRef);
+      currentMethodBody.getStatements().add(
+          new JReturnStatement(program, null, call));
+    }
+
+    private void writeEnumValuesMethod(JEnumType type) {
+      // return new E[]{A,B,C};
+      JNewArray newExpr = new JNewArray(program, null, program.getTypeArray(
+          type, 1));
+      newExpr.initializers = new ArrayList<JExpression>();
+      for (JEnumField field : type.enumList) {
+        JFieldRef fieldRef = new JFieldRef(program, null, null, field, type);
+        newExpr.initializers.add(fieldRef);
+      }
+      currentMethodBody.getStatements().add(
+          new JReturnStatement(program, null, newExpr));
+    }
   }
 
   /**
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java b/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java
index aa37346..ad688a5 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java
@@ -23,7 +23,6 @@
 import com.google.gwt.dev.jjs.ast.JBinaryOperator;
 import com.google.gwt.dev.jjs.ast.JClassLiteral;
 import com.google.gwt.dev.jjs.ast.JClassType;
-import com.google.gwt.dev.jjs.ast.JEnumField;
 import com.google.gwt.dev.jjs.ast.JExpression;
 import com.google.gwt.dev.jjs.ast.JField;
 import com.google.gwt.dev.jjs.ast.JFieldRef;
@@ -375,10 +374,6 @@
       if (target.isStatic()) {
         rescue(target.getEnclosingType(), true, false);
       }
-      // TODO: HACK
-      if (target instanceof JEnumField) {
-        rescue(((JEnumField) target).getEnclosingType(), true, true);
-      }
       rescue(target);
       return true;
     }
@@ -570,6 +565,9 @@
         /*
          * Any reference types (except String, which works by default) that take
          * part in a concat must rescue java.lang.Object.toString().
+         * 
+         * TODO: can we narrow the focus by walking up the type heirarchy or
+         * doing explicit toString calls?
          */
         JMethod toStringMethod = program.getIndexedMethod("Object.toString");
         rescue(toStringMethod);
diff --git a/user/super/com/google/gwt/emul/java/lang/Enum.java b/user/super/com/google/gwt/emul/java/lang/Enum.java
index f11649c..151b4b0 100644
--- a/user/super/com/google/gwt/emul/java/lang/Enum.java
+++ b/user/super/com/google/gwt/emul/java/lang/Enum.java
@@ -15,6 +15,8 @@
  */
 package java.lang;
 
+import com.google.gwt.core.client.JavaScriptObject;
+
 /**
  * The first-class representation of an enumeration.
  * 
@@ -22,6 +24,20 @@
  */
 public abstract class Enum<E extends Enum<E>> implements Comparable<E> {
 
+  protected static <T extends Enum<T>> T valueOf(JavaScriptObject map,
+      String name) {
+    T result = Enum.<T>valueOf0(map, "_" + name);
+    if (result == null) {
+      throw new IllegalArgumentException(name);
+    }
+    return result;
+  }
+
+  private static native <T extends Enum<T>> T valueOf0(JavaScriptObject map,
+      String name) /*-{
+    return map[name] || null;
+  }-*/;
+
   // public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name)
   // {
   // throw new UnsupportedOperationException("not yet implemented.");
diff --git a/user/test/com/google/gwt/dev/jjs/test/EnumsTest.java b/user/test/com/google/gwt/dev/jjs/test/EnumsTest.java
index 34dfcb9..460ee10 100644
--- a/user/test/com/google/gwt/dev/jjs/test/EnumsTest.java
+++ b/user/test/com/google/gwt/dev/jjs/test/EnumsTest.java
@@ -168,28 +168,46 @@
     assertEquals(Basic.A, Basic.valueOf("A"));
     assertEquals(Basic.B, Basic.valueOf("B"));
     assertEquals(Basic.C, Basic.valueOf("C"));
+    try {
+      Basic.valueOf("D");
+      fail("Basic.valueOf(\"D\") -- expected IllegalArgumentException");
+    } catch (IllegalArgumentException e) {
+    }
 
     assertEquals(Complex.A, Complex.valueOf("A"));
     assertEquals(Complex.B, Complex.valueOf("B"));
     assertEquals(Complex.C, Complex.valueOf("C"));
+    try {
+      Complex.valueOf("D");
+      fail("Complex.valueOf(\"D\") -- expected IllegalArgumentException");
+    } catch (IllegalArgumentException e) {
+    }
 
     assertEquals(Subclassing.A, Subclassing.valueOf("A"));
     assertEquals(Subclassing.B, Subclassing.valueOf("B"));
     assertEquals(Subclassing.C, Subclassing.valueOf("C"));
+    try {
+      Subclassing.valueOf("D");
+      fail("Subclassing.valueOf(\"D\") -- expected IllegalArgumentException");
+    } catch (IllegalArgumentException e) {
+    }
   }
 
   public void testValues() {
     Basic[] simples = Basic.values();
+    assertEquals(3, simples.length);
     assertEquals(Basic.A, simples[0]);
     assertEquals(Basic.B, simples[1]);
     assertEquals(Basic.C, simples[2]);
 
     Complex[] complexes = Complex.values();
+    assertEquals(3, complexes.length);
     assertEquals(Complex.A, complexes[0]);
     assertEquals(Complex.B, complexes[1]);
     assertEquals(Complex.C, complexes[2]);
 
     Subclassing[] subs = Subclassing.values();
+    assertEquals(3, subs.length);
     assertEquals(Subclassing.A, subs[0]);
     assertEquals(Subclassing.B, subs[1]);
     assertEquals(Subclassing.C, subs[2]);