diff --git a/dev/core/src/com/google/gwt/dev/javac/JdtUtil.java b/dev/core/src/com/google/gwt/dev/javac/JdtUtil.java
index fb03ec8..06e96a8 100644
--- a/dev/core/src/com/google/gwt/dev/javac/JdtUtil.java
+++ b/dev/core/src/com/google/gwt/dev/javac/JdtUtil.java
@@ -31,6 +31,8 @@
 import org.eclipse.jdt.internal.compiler.impl.BooleanConstant;
 import org.eclipse.jdt.internal.compiler.impl.StringConstant;
 import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
+import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;
+import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
 import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
 import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
 import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding;
@@ -40,6 +42,7 @@
 import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.SyntheticArgumentBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
+import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -445,4 +448,74 @@
       }
     });
   }
+
+  /*
+   * Implicit conversion helpers.
+   */
+
+  public static boolean requiresBoxing(int implicitConversion) {
+    return implicitConversion != -1
+        && (implicitConversion & TypeIds.BOXING) != 0;
+  }
+
+  public static boolean requiresUnboxing(int implicitConversion) {
+    return implicitConversion != -1
+        && (implicitConversion & TypeIds.UNBOXING) != 0;
+  }
+
+  public static BaseTypeBinding getBoxingPrimitiveType(ClassScope scope, int implicitConversion) {
+    int typeId = (implicitConversion & TypeIds.IMPLICIT_CONVERSION_MASK) >> 4;
+    return getBaseTypeBinding(scope, typeId);
+  }
+
+  public static BaseTypeBinding getUnboxingPrimitiveType(
+      ClassScope scope, int implicitConversion) {
+    if (needsCastBeforeUnbox(scope, implicitConversion)) {
+      int typeId = (implicitConversion & TypeIds.IMPLICIT_CONVERSION_MASK) >> 4;
+      return getBaseTypeBinding(scope, typeId);
+    }
+    int compileTypeId = implicitConversion & TypeIds.COMPILE_TYPE_MASK;
+    return getBaseTypeBinding(scope, compileTypeId);
+  }
+
+  public static BaseTypeBinding getBaseTypeBinding(ClassScope scope, int typeId) {
+    return  (BaseTypeBinding) TypeBinding.wellKnownType(scope, typeId);
+  }
+
+  public static ReferenceBinding getBoxedTypeBinding(
+      ClassScope scope, BaseTypeBinding primitiveType) {
+    return (ReferenceBinding) scope.boxing(primitiveType);
+  }
+
+  public static boolean needsCastBeforeUnbox(ClassScope scope, int implicitConversion) {
+    // values of specific types like j.l.Object need casting before auto unboxing.
+    int compileTypeId = implicitConversion & TypeIds.COMPILE_TYPE_MASK;
+    return !(TypeBinding.wellKnownType(scope, compileTypeId) instanceof BaseTypeBinding);
+  }
+
+  private static final String VALUE_SUFFIX = "Value";
+  private static final String VALUE_OF_METHOD_NAME = "valueOf";
+
+  private static final char[] VALUE_SUFFIX_ = VALUE_SUFFIX.toCharArray();
+  private static final char[] VALUE_OF_ = VALUE_OF_METHOD_NAME.toCharArray();
+
+  public static MethodBinding getBoxingMethodBinding(
+      ClassScope scope, BaseTypeBinding primitiveType) {
+    ReferenceBinding boxType = (ReferenceBinding) scope.boxing(primitiveType);
+    MethodBinding valueOfMethod = boxType.getExactMethod(VALUE_OF_,
+        new TypeBinding[]{primitiveType}, scope.compilationUnitScope());
+    assert valueOfMethod != null;
+    return valueOfMethod;
+  }
+
+  public static MethodBinding getUnboxingMethodBinding(
+      ClassScope scope, BaseTypeBinding primitiveType) {
+    ReferenceBinding boxType = (ReferenceBinding) scope.boxing(primitiveType);
+    char[] selector = CharOperation.concat(primitiveType.simpleName, VALUE_SUFFIX_);
+
+    MethodBinding valueMethod =
+        boxType.getExactMethod(selector, new TypeBinding[0], scope.compilationUnitScope());
+    assert valueMethod != null;
+    return valueMethod;
+  }
 }
diff --git a/dev/core/src/com/google/gwt/dev/javac/testing/impl/JavaResourceBase.java b/dev/core/src/com/google/gwt/dev/javac/testing/impl/JavaResourceBase.java
index 46bc6f5..aae771d 100644
--- a/dev/core/src/com/google/gwt/dev/javac/testing/impl/JavaResourceBase.java
+++ b/dev/core/src/com/google/gwt/dev/javac/testing/impl/JavaResourceBase.java
@@ -368,12 +368,18 @@
   public static final MockJavaResource SPECIALIZE_METHOD =
       createMockJavaResource("javaemul.internal.annotations.SpecializeMethod",
           "package javaemul.internal.annotations;",
-          "public @interface SpecializeMethod {\n",
-          "  Class<?>[] params();\n" +
-          "  String target();\n",
+          "public @interface SpecializeMethod {",
+          "  Class<?>[] params();",
+          "  String target();",
           "}"
       );
 
+  public static final MockJavaResource DO_NOT_AUTOBOX =
+      createMockJavaResource("javaemul.internal.annotations.DoNotAutobox",
+          "package javaemul.internal.annotations;",
+          "public @interface DoNotAutobox {\n",
+          "}"
+      );
   // TODO: move JS* annotations to intrinsic mock resource base
   public static final MockJavaResource JSTYPE =
       createMockJavaResource("jsinterop.annotations.JsType",
@@ -438,8 +444,8 @@
         ERROR, FUNCTIONALINTERFACE, FLOAT, INTEGER, IS_SERIALIZABLE, JAVASCRIPTEXCEPTION,
         JAVASCRIPTOBJECT, LIST, LONG, MAP, NO_CLASS_DEF_FOUND_ERROR, NUMBER, OBJECT,
         RUNTIME_EXCEPTION, SERIALIZABLE, SHORT, STRING, STRING_BUILDER, SUPPRESS_WARNINGS, SYSTEM,
-        THROWABLE, SPECIALIZE_METHOD, JSTYPE, JSCONSTRUCTOR, JSPACKAGE, JSPROPERTY, JSMETHOD,
-        JSIGNORE, JSFUNCTION, JSOVERLAY, JSOPTIONAL};
+        THROWABLE, SPECIALIZE_METHOD, DO_NOT_AUTOBOX, JSTYPE, JSCONSTRUCTOR, JSPACKAGE, JSPROPERTY,
+        JSMETHOD, JSIGNORE, JSFUNCTION, JSOVERLAY, JSOPTIONAL};
   }
 
   /**
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/GwtAstBuilder.java b/dev/core/src/com/google/gwt/dev/jjs/impl/GwtAstBuilder.java
index ba927d8..266a53a 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/GwtAstBuilder.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/GwtAstBuilder.java
@@ -125,7 +125,6 @@
 import com.google.gwt.thirdparty.guava.common.collect.Sets;
 import com.google.gwt.util.regexfilter.WhitelistRegexFilter;
 
-import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.ast.AND_AND_Expression;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
@@ -379,7 +378,7 @@
     public void endVisit(AllocationExpression x, BlockScope scope) {
       try {
         SourceInfo info = makeSourceInfo(x);
-        List<JExpression> arguments = popCallArgs(info, x.arguments, x.binding);
+        List<JExpression> arguments = popCallArguments(info, x.arguments, x.binding);
         pushNewExpression(info, x, null, arguments, scope);
       } catch (Throwable e) {
         throw translateException(x, e);
@@ -405,7 +404,7 @@
         if (x.initializer != null) {
           // handled by ArrayInitializer.
         } else {
-          List<JExpression> dims = pop(x.dimensions);
+          List<JExpression> dims = performBoxUnboxConversions(pop(x.dimensions), x.dimensions);
           push(JNewArray.createArrayWithDimensionExpressions(info, type, dims));
         }
       } catch (Throwable e) {
@@ -418,7 +417,8 @@
       try {
         SourceInfo info = makeSourceInfo(x);
         JArrayType type = (JArrayType) typeMap.get(x.resolvedType);
-        List<JExpression> expressions = pop(x.expressions);
+        List<JExpression> expressions =
+            performBoxUnboxConversions(pop(x.expressions), x.expressions);
         push(JNewArray.createArrayWithInitializers(info, type, expressions));
       } catch (Throwable e) {
         throw translateException(x, e);
@@ -773,7 +773,7 @@
         JConstructor ctor = (JConstructor) typeMap.get(x.binding);
         JExpression trueQualifier = makeThisRef(info);
         JMethodCall call = new JMethodCall(info, trueQualifier, ctor);
-        List<JExpression> callArgs = popCallArgs(info, x.arguments, x.binding);
+        List<JExpression> callArgs = popCallArguments(info, x.arguments, x.binding);
 
         if (curClass.classType.isEnumOrSubclass() != null) {
           // Enums: wire up synthetic name/ordinal params to the super method.
@@ -1367,7 +1367,7 @@
       // Deal with any boxing/unboxing needed
       JNode node = pop();
       if (node instanceof JExpression) {
-        node = simplify((JExpression) node, (Expression) x.body);
+        node = maybeBoxOrUnbox((JExpression) node, (Expression) x.body);
       }
 
       JMethodBody body = (JMethodBody) curMethod.method.getBody();
@@ -1525,7 +1525,7 @@
         SourceInfo info = makeSourceInfo(x);
         JMethod method = typeMap.get(x.binding);
 
-        List<JExpression> arguments = popCallArgs(info, x.arguments, x.binding);
+        List<JExpression> arguments = popCallArguments(info, x.arguments, x.binding);
         JExpression receiver = pop(x.receiver);
         if (x.receiver instanceof ThisReference) {
           if (method.isStatic()) {
@@ -1560,7 +1560,7 @@
         if (x.valueCast != null) {
           JType[] targetTypes = processCastType(x.valueCast);
           push(isUncheckedGenericMethodCall(x)
-              ? maybeInsertUnsafeTypeCoersion(targetTypes[0], methodCall)
+              ? maybeInsertUnsafeTypeCoercion(targetTypes[0], methodCall)
               : maybeCast(targetTypes, methodCall));
         } else {
           push(methodCall);
@@ -1649,7 +1649,7 @@
     public void endVisit(QualifiedAllocationExpression x, BlockScope scope) {
       try {
         SourceInfo info = makeSourceInfo(x);
-        List<JExpression> arguments = popCallArgs(info, x.arguments, x.binding);
+        List<JExpression> arguments = popCallArguments(info, x.arguments, x.binding);
         pushNewExpression(info, x, x.enclosingInstance(), arguments, scope);
       } catch (Throwable e) {
         throw translateException(x, e);
@@ -1939,7 +1939,7 @@
       if (samMethod.getType() != JPrimitiveType.VOID) {
         JExpression samExpression = boxOrUnboxExpression(samCall, referredMethodBinding.returnType,
             declarationSamBinding.returnType);
-        samMethodBody.getBlock().addStmt(simplify(samExpression, x).makeReturnStatement());
+        samMethodBody.getBlock().addStmt(maybeBoxOrUnbox(samExpression, x).makeReturnStatement());
       } else {
         samMethodBody.getBlock().addStmt(samCall.makeStatement());
       }
@@ -1985,15 +1985,11 @@
       }
 
       if (fromType.isBaseType() && !toType.isBaseType()) {
-        int implicitConversion = (fromType.id & TypeIds.IMPLICIT_CONVERSION_MASK) << 4;
-        implicitConversion = implicitConversion | TypeIds.BOXING;
-        return box(expr, implicitConversion);
+        return box(expr, JdtUtil.getBaseTypeBinding(curClass.scope, fromType.id));
       }
 
       if (!fromType.isBaseType() && toType.isBaseType()) {
-        int implicitConversion = (toType.id & TypeIds.IMPLICIT_CONVERSION_MASK) << 4;
-        implicitConversion = implicitConversion | TypeIds.UNBOXING;
-        return unbox(expr, implicitConversion);
+        return unbox(expr, JdtUtil.getBaseTypeBinding(curClass.scope, toType.id));
       }
 
       TypeBinding castToType = fromType.genericCast(toType);
@@ -2585,23 +2581,26 @@
         assert x instanceof NameReference;
         return null;
       }
-      result = simplify(result, x);
+      result = maybeBoxOrUnbox(result, x);
+      return result;
+    }
+
+    protected <T extends JExpression> List<T> performBoxUnboxConversions(
+        List<T> result, Expression[] expressions) {
+      for (int i = 0; i < result.size(); i++) {
+        result.set(i, (T) maybeBoxOrUnbox(result.get(i), expressions[i]));
+      }
       return result;
     }
 
     @SuppressWarnings("unchecked")
-    protected <T extends JExpression> List<T> pop(Expression[] expressions) {
+    protected List<JExpression> pop(Expression[] expressions) {
       if (expressions == null) {
         return Collections.emptyList();
       }
 
-      List<T> result = (List<T>) popList(Collections2.filter(Arrays.asList(expressions),
+      return  (List<JExpression>) popList(Collections2.filter(Arrays.asList(expressions),
           Predicates.notNull()).size());
-
-      for (int i = 0; i < result.size(); i++) {
-        result.set(i, (T) simplify(result.get(i), expressions[i]));
-      }
-      return result;
     }
 
     protected JDeclarationStatement pop(LocalDeclaration decl) {
@@ -2611,7 +2610,7 @@
     protected JStatement pop(Statement x) {
       JNode pop = (x == null) ? null : pop();
       if (x instanceof Expression) {
-        return simplify((JExpression) pop, (Expression) x).makeStatement();
+        return maybeBoxOrUnbox((JExpression) pop, (Expression) x).makeStatement();
       }
       return (JStatement) pop;
     }
@@ -2628,7 +2627,8 @@
         if (element == null) {
           it.remove();
         } else if (element instanceof JExpression) {
-          it.set((T) simplify((JExpression) element, (Expression) statements[i]).makeStatement());
+          it.set((T)
+              maybeBoxOrUnbox((JExpression) element, (Expression) statements[i]).makeStatement());
         }
       }
       return result;
@@ -2756,25 +2756,47 @@
           new JBinaryOperation(info, lhs.getType(), JBinaryOperator.ASG, lhs, param.makeRef(info));
     }
 
-    private JExpression box(JExpression original, int implicitConversion) {
-      int typeId = (implicitConversion & TypeIds.IMPLICIT_CONVERSION_MASK) >> 4;
-      ClassScope scope = curClass.scope;
-      BaseTypeBinding primitiveType = (BaseTypeBinding) TypeBinding.wellKnownType(scope, typeId);
-      ReferenceBinding boxType = (ReferenceBinding) scope.boxing(primitiveType);
-      MethodBinding valueOfMethod = boxType.getExactMethod(VALUE_OF_,
-          new TypeBinding[]{primitiveType}, scope.compilationUnitScope());
-      assert valueOfMethod != null;
+    private JExpression box(JExpression original, BaseTypeBinding primitiveType) {
+      return box(original, primitiveType, false);
+    }
 
+    private JExpression box(
+        JExpression original, BaseTypeBinding primitiveType, boolean doNotAutobox) {
       // Add a cast to the correct primitive type if needed.
       JType targetPrimitiveType = typeMap.get(primitiveType);
       if (original.getType() != targetPrimitiveType) {
         original = new JCastOperation(original.getSourceInfo(), targetPrimitiveType, original);
       }
 
-      JMethod boxMethod = typeMap.get(valueOfMethod);
-      JMethodCall call = new JMethodCall(original.getSourceInfo(), null, boxMethod);
-      call.addArg(original);
-      return call;
+      if (doNotAutobox) {
+        // Protect the primitive @DoNotAutobox values from optimizations, etc but encapsulating
+        // them in an opaque unsafe coercion to Object.
+        return new JUnsafeTypeCoercion(original.getSourceInfo(), javaLangObject, original);
+      }
+
+      ClassScope scope = curClass.scope;
+      JMethod boxingMethod = typeMap.get(JdtUtil.getBoxingMethodBinding(scope, primitiveType));
+      return new JMethodCall(original.getSourceInfo(), null, boxingMethod, original);
+    }
+
+    private JExpression unbox(JExpression original, BaseTypeBinding primitiveType) {
+      return unbox(original, primitiveType, true);
+    }
+
+    private JExpression unbox(
+        JExpression original, BaseTypeBinding primitiveType, boolean needsExplicitCast) {
+
+      ClassScope scope = curClass.scope;
+      if (needsExplicitCast) {
+        // Direct cast from non-boxed-type reference type to a primitive type,
+        // wrap with a cast operation of the (boxed) expected type.
+        JReferenceType boxedType =
+            (JReferenceType) typeMap.get(JdtUtil.getBoxedTypeBinding(scope, primitiveType));
+        original =
+            new JCastOperation(original.getSourceInfo(), boxedType, original);
+      }
+      JMethod unboxingMethod = typeMap.get(JdtUtil.getUnboxingMethodBinding(scope, primitiveType));
+      return new JMethodCall(original.getSourceInfo(), original, unboxingMethod);
     }
 
     private void createBridgeMethod(SyntheticMethodBinding jdtBridgeMethod) {
@@ -3063,12 +3085,18 @@
     }
 
     private JExpression maybeBoxOrUnbox(JExpression original, int implicitConversion) {
-      if (implicitConversion != -1) {
-        if ((implicitConversion & TypeIds.BOXING) != 0) {
-          return box(original, implicitConversion);
-        } else if ((implicitConversion & TypeIds.UNBOXING) != 0) {
-          return unbox(original, implicitConversion);
-        }
+      return maybeBoxOrUnbox(original, implicitConversion, false);
+    }
+
+    private JExpression maybeBoxOrUnbox(
+        JExpression original, int implicitConversion, boolean doNotAutobox) {
+      if (JdtUtil.requiresBoxing(implicitConversion)) {
+        return box(original, JdtUtil.getBoxingPrimitiveType(curClass.scope, implicitConversion),
+            doNotAutobox);
+      }
+      if (JdtUtil.requiresUnboxing(implicitConversion)) {
+        return unbox(original, JdtUtil.getUnboxingPrimitiveType(curClass.scope, implicitConversion),
+            JdtUtil.needsCastBeforeUnbox(curClass.scope, implicitConversion));
       }
       return original;
     }
@@ -3088,7 +3116,7 @@
       return expression;
     }
 
-      private JExpression maybeInsertUnsafeTypeCoersion(JType expected, JExpression expression) {
+      private JExpression maybeInsertUnsafeTypeCoercion(JType expected, JExpression expression) {
       if (expected != expression.getType()) {
         // A generic call marked as @UncheckedCast.
         return new JUnsafeTypeCoercion(expression.getSourceInfo(), expected, expression);
@@ -3101,25 +3129,33 @@
       return nodeStack.remove(nodeStack.size() - 1);
     }
 
-    private List<JExpression> popCallArgs(SourceInfo info, Expression[] jdtArgs,
-        MethodBinding binding) {
-      List<JExpression> args = pop(jdtArgs);
-      if (!binding.isVarargs()) {
+    private List<JExpression> popCallArguments(SourceInfo info, Expression[] arguments,
+        MethodBinding methodBinding) {
+      List<JExpression> args = pop(arguments);
+      for (int i = 0; i < args.size(); i++) {
+        // Account for varargs parameter.
+        int parameterIndex = Math.min(i, methodBinding.parameters.length - 1);
+        args.set(i, maybeBoxOrUnbox(
+            args.get(i),
+            arguments[i].implicitConversion,
+            isDoNotAutoBoxParameter(methodBinding, parameterIndex)));
+      }
+      if (!methodBinding.isVarargs()) {
         return args;
       }
 
       // Handle the odd var-arg case.
-      if (jdtArgs == null) {
+      if (arguments == null) {
         // Get writable collection (args is currently Collections.emptyList()).
         args = Lists.newArrayListWithCapacity(1);
       }
 
-      TypeBinding[] params = binding.parameters;
+      TypeBinding[] params = methodBinding.parameters;
       int varArg = params.length - 1;
 
       // See if there's a single varArg which is already an array.
       if (args.size() == params.length) {
-        if (jdtArgs[varArg].resolvedType.isCompatibleWith(params[varArg])) {
+        if (arguments[varArg].resolvedType.isCompatibleWith(params[varArg])) {
           // Already the correct array type.
           return args;
         }
@@ -3135,6 +3171,15 @@
       return args;
     }
 
+    private boolean isDoNotAutoBoxParameter(MethodBinding methodBinding, int parameterIndex) {
+      AnnotationBinding[][] parameterAnnotations = methodBinding.getParameterAnnotations();
+      return parameterAnnotations != null
+          && parameterAnnotations.length > parameterIndex
+          && parameterAnnotations[parameterIndex] != null
+          && JdtUtil.getAnnotationByName(parameterAnnotations[parameterIndex],
+          "javaemul.internal.annotations.DoNotAutobox") != null;
+    }
+
     private List<? extends JNode> popList(int count) {
       List<JNode> tail = nodeStack.subList(nodeStack.size() - count, nodeStack.size());
       // Make a copy.
@@ -3455,7 +3500,7 @@
       return result;
     }
 
-    private JExpression simplify(JExpression result, Expression x) {
+    private JExpression maybeBoxOrUnbox(JExpression result, Expression x) {
       return maybeBoxOrUnbox(result, x.implicitConversion);
     }
 
@@ -3467,34 +3512,6 @@
       return expression;
     }
 
-    private JExpression unbox(JExpression original, int implicitConversion) {
-      int compileTypeId = implicitConversion & TypeIds.COMPILE_TYPE_MASK;
-      ClassScope scope = curClass.scope;
-      TypeBinding targetBinding = TypeBinding.wellKnownType(scope, compileTypeId);
-      if (!(targetBinding instanceof BaseTypeBinding)) {
-        // Direct cast from non-boxed-type reference type to a primitive type,
-        // wrap with a cast operation of the (boxed) expected type.
-        int runtimeTypeId = (implicitConversion & TypeIds.IMPLICIT_CONVERSION_MASK) >> 4;
-        TypeBinding runtimeTypeBinding = TypeBinding.wellKnownType(scope, runtimeTypeId);
-        ReferenceBinding boxType = (ReferenceBinding) scope.boxing(runtimeTypeBinding);
-        original =
-            new JCastOperation(original.getSourceInfo(), typeMap.get(boxType), original);
-        targetBinding = runtimeTypeBinding;
-        assert (targetBinding instanceof BaseTypeBinding);
-      }
-
-      BaseTypeBinding primitiveType = (BaseTypeBinding) targetBinding;
-
-      ReferenceBinding boxType = (ReferenceBinding) scope.boxing(primitiveType);
-      char[] selector = CharOperation.concat(primitiveType.simpleName, VALUE_SUFFIX_);
-      MethodBinding valueMethod =
-          boxType.getExactMethod(selector, NO_TYPES, scope.compilationUnitScope());
-      assert valueMethod != null;
-      JMethod unboxMethod = typeMap.get(valueMethod);
-      JMethodCall call = new JMethodCall(original.getSourceInfo(), original, unboxMethod);
-      return call;
-    }
-
     private void writeEnumValueOfMethod(JEnumType type, JMethod method, JMethod valuesMethod) {
       JField mapField;
       TypeBinding mapType;
@@ -3732,10 +3749,8 @@
 
   private static final String CREATE_VALUE_OF_MAP_METHOD_NAME = "createValueOfMap";
   private static final String LENGTH_FIELD_NAME = "length";
-  private static final String VALUE_SUFFIX = "Value";
 
   private static final char[] CREATE_VALUE_OF_MAP_ = CREATE_VALUE_OF_MAP_METHOD_NAME.toCharArray();
-  private static final char[] VALUE_SUFFIX_ = VALUE_SUFFIX.toCharArray();
   private static final char[] VALUE_OF_ = VALUE_OF_METHOD_NAME.toCharArray();
   private static final char[] VALUES_ = VALUES_METHOD_NAME.toCharArray();
   private static final char[] ORDINAL_ = ORDINAL_METHOD_NAME.toCharArray();
diff --git a/user/super/com/google/gwt/emul/javaemul/internal/annotations/DoNotAutobox.java b/user/super/com/google/gwt/emul/javaemul/internal/annotations/DoNotAutobox.java
new file mode 100644
index 0000000..479548f
--- /dev/null
+++ b/user/super/com/google/gwt/emul/javaemul/internal/annotations/DoNotAutobox.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2017 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 javaemul.internal.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation to prevent autoboxing of arguments on method calls.
+ */
+@Target(ElementType.PARAMETER)
+public @interface DoNotAutobox {
+}
diff --git a/user/test/com/google/gwt/core/interop/JsMethodTest.java b/user/test/com/google/gwt/core/interop/JsMethodTest.java
index dd3124d..828e016 100644
--- a/user/test/com/google/gwt/core/interop/JsMethodTest.java
+++ b/user/test/com/google/gwt/core/interop/JsMethodTest.java
@@ -19,6 +19,7 @@
 
 import com.google.gwt.junit.client.GWTTestCase;
 
+import javaemul.internal.annotations.DoNotAutobox;
 import jsinterop.annotations.JsMethod;
 import jsinterop.annotations.JsProperty;
 
@@ -80,4 +81,36 @@
     setJsInteropSecret("very secret!");
     assertEquals("very secret!", getJsInteropSecret());
   }
+
+  public static double returnWithoutBoxing(@DoNotAutobox Object object) {
+    return (Double) object;
+  }
+
+  public static double sumWithoutBoxing(@DoNotAutobox Object... objects) {
+    double sum = 0;
+    for (Object o : objects) {
+      sum += (Double) o;
+    }
+    return sum;
+  }
+
+  @JsMethod
+  public static double sumWithoutBoxingJsVarargs(@DoNotAutobox Object... objects) {
+    double sum = 0;
+    for (Object o : objects) {
+      sum += (Double) o;
+    }
+    return sum;
+  }
+
+  public void testDoNotAutobox() {
+    assertEquals(3.0, returnWithoutBoxing(3));
+    assertEquals(4.5, sumWithoutBoxing(1, 1.5, (short) 1, (byte) 1));
+    assertEquals(4.5, sumWithoutBoxingJsVarargs(1, 1.5, (short) 1, (byte) 1));
+    try {
+      returnWithoutBoxing(Long.MAX_VALUE);
+      fail("Should have thrown ClassCastException");
+    } catch (ClassCastException expected) {
+    }
+  }
 }