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 b51c265..0956e3f 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
@@ -176,6 +176,7 @@
 import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
 import org.eclipse.jdt.internal.compiler.util.Util;
 
+import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
@@ -1193,13 +1194,7 @@
       JExpression fieldRef = new JFieldRef(program, info, instance, field,
           currentClass);
 
-      if (type != field.getType()) {
-        // Must be a generic; insert a cast operation.
-        JReferenceType toType = (JReferenceType) type;
-        return new JCastOperation(program, info, toType, fieldRef);
-      } else {
-        return fieldRef;
-      }
+      return maybeCast(type, fieldRef);
     }
 
     JExpression processExpression(InstanceOfExpression x) {
@@ -1247,13 +1242,7 @@
       // The arguments come first...
       addCallArgs(x.arguments, call, x.binding);
 
-      if (type != method.getType()) {
-        // Must be a generic; insert a cast operation.
-        JReferenceType toType = (JReferenceType) type;
-        return new JCastOperation(program, info, toType, call);
-      } else {
-        return call;
-      }
+      return maybeCast(type, call);
     }
 
     @SuppressWarnings("unused")
@@ -1763,17 +1752,26 @@
             program.getIndexedMethod("Iterator.hasNext"));
 
         // T elementVar = (T) i$iterator.next();
-        JMethodCall nextCall = new JMethodCall(program, info,
+        elementDecl.initializer = new JMethodCall(program, info,
             createVariableRef(info, iteratorVar),
             program.getIndexedMethod("Iterator.next"));
 
-        JType elementType = elementDecl.getVariableRef().getType();
-        if (elementType != nextCall.getType()) {
-          // Must be a generic; insert a cast operation.
-          elementDecl.initializer = new JCastOperation(program, info,
-              elementType, nextCall);
-        } else {
-          elementDecl.initializer = nextCall;
+        // Perform any implicit reference type casts (due to generics).
+        // Note this occurs before potential unboxing.
+        if (elementVar.getType() != program.getTypeJavaLangObject()) {
+          TypeBinding collectionType;
+          try {
+            Field privateField = ForeachStatement.class.getDeclaredField("collectionElementType");
+            privateField.setAccessible(true);
+            collectionType = (TypeBinding) privateField.get(x);
+          } catch (Exception e) {
+            throw new InternalCompilerException(elementDecl,
+                "Failed to retreive collectionElementType through reflection",
+                e);
+          }
+          JType toType = (JType) typeMap.get(collectionType);
+          assert (toType instanceof JReferenceType);
+          elementDecl.initializer = maybeCast(toType, elementDecl.initializer);
         }
 
         body.statements.add(0, elementDecl);
@@ -1782,14 +1780,14 @@
             Collections.<JExpressionStatement> emptyList(), body);
       }
 
-      // May need to box or unbox the assignment.
+      // May need to box or unbox the element assignment.
       if (x.elementVariableImplicitWidening != -1) {
         if ((x.elementVariableImplicitWidening & TypeIds.BOXING) != 0) {
           elementDecl.initializer = box(elementDecl.initializer,
-              (JClassType) elementVar.getType());
+              (JPrimitiveType) elementDecl.initializer.getType());
         } else if ((x.elementVariableImplicitWidening & TypeIds.UNBOXING) != 0) {
           elementDecl.initializer = unbox(elementDecl.initializer,
-              (JPrimitiveType) elementVar.getType());
+              (JClassType) elementDecl.initializer.getType());
         }
       }
       return result;
@@ -2106,12 +2104,14 @@
       }
     }
 
-    private JExpression box(JExpression toBox, JClassType wrapperType) {
-      JPrimitiveType primitiveType = getPrimitiveTypeForWrapperType(wrapperType);
-      if (primitiveType == null) {
-        throw new InternalCompilerException(toBox,
-            "Failed to find primitive type for wrapper type '"
-                + wrapperType.getName() + "'", null);
+    private JExpression box(JExpression toBox, JPrimitiveType primitiveType) {
+      // Find the wrapper type for this primitive type.
+      String wrapperTypeName = primitiveType.getWrapperTypeName();
+      JClassType wrapperType = (JClassType) program.getFromTypeMap(wrapperTypeName);
+      if (wrapperType == null) {
+        throw new InternalCompilerException(toBox, "Cannot find wrapper type '"
+            + wrapperTypeName + "' associated with primitive type '"
+            + primitiveType.getName() + "'", null);
       }
 
       // Find the correct valueOf() method.
@@ -2145,18 +2145,6 @@
       return call;
     }
 
-    private JExpression box(JExpression toBox, JPrimitiveType primitiveType) {
-      // Find the wrapper type for this primitive type.
-      String wrapperTypeName = primitiveType.getWrapperTypeName();
-      JClassType wrapperType = (JClassType) program.getFromTypeMap(wrapperTypeName);
-      if (wrapperType == null) {
-        throw new InternalCompilerException(toBox, "Cannot find wrapper type '"
-            + wrapperTypeName + "' associated with primitive type '"
-            + primitiveType.getName() + "'", null);
-      }
-      return box(toBox, wrapperType);
-    }
-
     private JDeclarationStatement createDeclaration(SourceInfo info,
         JLocal local, JExpression value) {
       return new JDeclarationStatement(program, info, new JLocalRef(program,
@@ -2380,6 +2368,17 @@
           currentFileName);
     }
 
+    private JExpression maybeCast(JType expected, JExpression expression) {
+      if (expected != expression.getType()) {
+        // Must be a generic; insert a cast operation.
+        JReferenceType toType = (JReferenceType) expected;
+        return new JCastOperation(program, expression.getSourceInfo(), toType,
+            expression);
+      } else {
+        return expression;
+      }
+    }
+
     /**
      * Sometimes a variable reference can be to a local or parameter in an an
      * enclosing method. This is a tricky situation to detect. There's no
@@ -2615,18 +2614,6 @@
       return unboxCall;
     }
 
-    private JExpression unbox(JExpression toUnbox, JPrimitiveType primitiveType) {
-      String wrapperTypeName = primitiveType.getWrapperTypeName();
-      JClassType wrapperType = (JClassType) program.getFromTypeMap(wrapperTypeName);
-      if (wrapperType == null) {
-        throw new InternalCompilerException(toUnbox,
-            "Cannot find wrapper type '" + wrapperTypeName
-                + "' associated with primitive type '"
-                + primitiveType.getName() + "'", null);
-      }
-      return unbox(toUnbox, wrapperType);
-    }
-
     private void writeEnumValueOfMethod(JEnumType type, JField mapField) {
       // return Enum.valueOf(map, name);
       JFieldRef mapRef = new JFieldRef(program, null, null, mapField, type);
diff --git a/user/test/com/google/gwt/dev/jjs/test/AutoboxTest.java b/user/test/com/google/gwt/dev/jjs/test/AutoboxTest.java
index 28e88a3..db1d304 100644
--- a/user/test/com/google/gwt/dev/jjs/test/AutoboxTest.java
+++ b/user/test/com/google/gwt/dev/jjs/test/AutoboxTest.java
@@ -97,12 +97,17 @@
     assertTrue(unbox(unboxedDouble) == unboxedDouble);
   }
 
-  /*
-   * TODO: Determine whether we fully support the JLS spec in regards to caching
-   * of autoboxed values.
-   * 
-   * public void testCaching() { }
+  /**
+   * Verify that .valueOf() methods return identical references for types within
+   * certain ranges.
    */
+  public void testCaching() {
+    assertSame((byte) 3, (byte) 3);
+    assertSame('A', 'A');
+    assertSame((short) 120, (short) 120);
+    assertSame(-13, -13);
+    assertSame(7L, 7L);
+  }
 
   public void testUnboxing() {
     boolean boolean_ = boxedBoolean;
@@ -143,6 +148,52 @@
     assertTrue(box(boxedDouble).doubleValue() == unboxedDouble);
   }
 
+  public void testUnboxingDifferentType() {
+    {
+      short short_ = boxedByte;
+      assertTrue(short_ == boxedByte.byteValue());
+      int int_ = boxedByte;
+      assertTrue(int_ == boxedByte.byteValue());
+      long long_ = boxedByte;
+      assertTrue(long_ == boxedByte.byteValue());
+      float float_ = boxedByte;
+      assertTrue(float_ == boxedByte.byteValue());
+      double double_ = boxedByte;
+      assertTrue(double_ == boxedByte.byteValue());
+    }
+
+    {
+      int int_ = boxedShort;
+      assertTrue(int_ == boxedShort.shortValue());
+      long long_ = boxedShort;
+      assertTrue(long_ == boxedShort.shortValue());
+      float float_ = boxedShort;
+      assertTrue(float_ == boxedShort.shortValue());
+      double double_ = boxedShort;
+      assertTrue(double_ == boxedShort.shortValue());
+    }
+
+    {
+      int int_ = boxedChar;
+      assertTrue(int_ == boxedChar.charValue());
+      long long_ = boxedChar;
+      assertTrue(long_ == boxedChar.charValue());
+      float float_ = boxedChar;
+      assertTrue(float_ == boxedChar.charValue());
+      double double_ = boxedChar;
+      assertTrue(double_ == boxedChar.charValue());
+    }
+
+    {
+      long long_ = boxedInt;
+      assertTrue(long_ == boxedInt.intValue());
+      float float_ = boxedInt;
+      assertTrue(float_ == boxedInt.intValue());
+      double double_ = boxedInt;
+      assertTrue(double_ == boxedInt.intValue());
+    }
+  }
+
   private Boolean box(boolean b) {
     return b;
   }
diff --git a/user/test/com/google/gwt/dev/jjs/test/EnhancedForLoopTest.java b/user/test/com/google/gwt/dev/jjs/test/EnhancedForLoopTest.java
index ec742e8..e8688b7 100644
--- a/user/test/com/google/gwt/dev/jjs/test/EnhancedForLoopTest.java
+++ b/user/test/com/google/gwt/dev/jjs/test/EnhancedForLoopTest.java
@@ -47,6 +47,14 @@
     }
     assertTrue(out.equals(items));
 
+    // Tests auto-unboxing.
+    List<Long> itemsL = Arrays.asList(1L, 2L, 3L, 4L, 5L);
+    List<Long> outL = new ArrayList<Long>();
+    for (long l : items) {
+      outL.add(l);
+    }
+    assertTrue(outL.equals(itemsL));
+
     int[] unboxedItems = new int[] {1, 2, 3, 4, 5};
     out.clear();
 
@@ -54,6 +62,7 @@
       out.add(i);
     }
 
+    // Tests auto-boxing.
     for (int i = 0; i < 5; ++i) {
       assertTrue(out.get(i).intValue() == unboxedItems[i]);
     }
@@ -76,4 +85,4 @@
     }
     assertTrue(out.equals(items));
   }
-}
\ No newline at end of file
+}