diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index 019d295..cab8542 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -180,6 +180,10 @@
     obsolete = true;
   }
 
+  public CompilationState getCompilationState() {
+    return compilationState;
+  }
+
   public DexEncodedMethod getDefaultInterfaceMethodImplementation() {
     return defaultInterfaceMethodImplementation;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index 3f74b74..6cbf350 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -739,7 +739,11 @@
     }
     if (enumUnboxer != null) {
       enumUnboxer.finishAnalysis();
-      enumUnboxer.unboxEnums(postMethodProcessorBuilder, executorService, feedback);
+      enumUnboxer.unboxEnums(
+          postMethodProcessorBuilder,
+          executorService,
+          feedback,
+          classStaticizer == null ? Collections.emptySet() : classStaticizer.getCandidates());
     }
     if (!options.debug) {
       new TrivialFieldAccessReprocessor(appView.withLiveness(), postMethodProcessorBuilder)
@@ -1763,6 +1767,11 @@
         || definition.getOptimizationInfo().isReachabilitySensitive()) {
       return false;
     }
+    if (appView.options().enableEnumUnboxing && method.getHolder().isEnum()) {
+      // Although the method is pinned, we compute the inlining constraint for enum unboxing,
+      // but the inliner won't be able to inline the method (marked as pinned).
+      return true;
+    }
     if (appView.appInfo().hasLiveness()
         && appView.appInfo().withLiveness().isPinned(method.getReference())) {
       return false;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
index e98ecfa..a74b4b6 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
@@ -51,6 +51,7 @@
 import com.android.tools.r8.ir.conversion.IRConverter;
 import com.android.tools.r8.ir.conversion.PostMethodProcessor;
 import com.android.tools.r8.ir.conversion.PostOptimization;
+import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import com.android.tools.r8.ir.optimize.info.FieldOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
 import com.android.tools.r8.ir.optimize.info.OptimizationFeedback.OptimizationInfoFixer;
@@ -68,6 +69,9 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
@@ -83,6 +87,7 @@
   // Map the enum candidates with their dependencies, i.e., the methods to reprocess for the given
   // enum if the optimization eventually decides to unbox it.
   private final Map<DexType, ProgramMethodSet> enumsUnboxingCandidates;
+  private final Set<DexType> enumsToUnboxWithPackageRequirement = Sets.newIdentityHashSet();
 
   private EnumUnboxingRewriter enumUnboxerRewriter;
 
@@ -328,7 +333,8 @@
   public void unboxEnums(
       PostMethodProcessor.Builder postBuilder,
       ExecutorService executorService,
-      OptimizationFeedbackDelayed feedback)
+      OptimizationFeedbackDelayed feedback,
+      Set<DexType> hostsToAvoidIfPossible)
       throws ExecutionException {
     // At this point the enumsToUnbox are no longer candidates, they will all be unboxed.
     if (enumsUnboxingCandidates.isEmpty()) {
@@ -338,7 +344,10 @@
     // Update keep info on any of the enum methods of the removed classes.
     updatePinnedItems(enumsToUnbox);
     enumUnboxerRewriter = new EnumUnboxingRewriter(appView, enumsToUnbox);
-    NestedGraphLens enumUnboxingLens = new TreeFixer(enumsToUnbox).fixupTypeReferences();
+    Map<DexType, DexType> newMethodLocation =
+        findNewMethodLocationOfUnboxableEnums(enumsToUnbox, hostsToAvoidIfPossible);
+    NestedGraphLens enumUnboxingLens =
+        new TreeFixer(enumsToUnbox).fixupTypeReferences(newMethodLocation);
     appView.setUnboxedEnums(enumUnboxerRewriter.getEnumsToUnbox());
     GraphLens previousLens = appView.graphLens();
     appView.rewriteWithLens(enumUnboxingLens);
@@ -378,6 +387,84 @@
     postBuilder.rewrittenWithLens(appView, previousLens);
   }
 
+  // Some enums may have methods which require to stay in the current package for accessibility,
+  // in this case we find another class than the enum unboxing utility class to host these methods.
+  private Map<DexType, DexType> findNewMethodLocationOfUnboxableEnums(
+      Set<DexType> enumsToUnbox, Set<DexType> hostsToAvoidIfPossible) {
+    if (enumsToUnboxWithPackageRequirement.isEmpty()) {
+      return Collections.emptyMap();
+    }
+    Map<DexType, DexType> newMethodLocationMap = new IdentityHashMap<>();
+    Map<String, DexProgramClass> packageToClassMap =
+        getPackageToClassMapExcluding(enumsToUnbox, hostsToAvoidIfPossible);
+    for (DexType toUnbox : enumsToUnboxWithPackageRequirement) {
+      DexProgramClass packageClass = packageToClassMap.get(toUnbox.getPackageDescriptor());
+      if (packageClass != null) {
+        newMethodLocationMap.put(toUnbox, packageClass.type);
+      }
+    }
+    enumsToUnboxWithPackageRequirement.clear();
+    return newMethodLocationMap;
+  }
+
+  // We are looking for another class in the same package as the unboxed enum to host the unboxed
+  // enum methods. We go through all classes, and for each package where a host is needed, we
+  // select a class.
+  private Map<String, DexProgramClass> getPackageToClassMapExcluding(
+      Set<DexType> enumsToUnbox, Set<DexType> hostsToAvoidIfPossible) {
+    HashSet<String> relevantPackages = new HashSet<>();
+    for (DexType toUnbox : enumsToUnbox) {
+      relevantPackages.add(toUnbox.getPackageDescriptor());
+    }
+
+    Map<String, DexProgramClass> packageToClassMap = new HashMap<>();
+    for (DexProgramClass clazz : appView.appInfo().classes()) {
+      String packageDescriptor = clazz.type.getPackageDescriptor();
+      if (relevantPackages.contains(packageDescriptor) && !enumsToUnbox.contains(clazz.type)) {
+        DexProgramClass previousClass = packageToClassMap.get(packageDescriptor);
+        if (previousClass == null) {
+          packageToClassMap.put(packageDescriptor, clazz);
+        } else {
+          packageToClassMap.put(
+              packageDescriptor, selectHost(clazz, previousClass, hostsToAvoidIfPossible));
+        }
+      }
+    }
+
+    return packageToClassMap;
+  }
+
+  // We are trying to select a host for the enum unboxing methods, but multiple candidates are
+  // available. We need to pick one of the two classes and the result has to be deterministic.
+  // We follow the heuristics, in order:
+  //  1. don't pick a class from hostToAvoidIfPossible if possible
+  //  2. pick the class with the least number of methods
+  //  3. pick the first class name in alphabetical order for determinism.
+  private DexProgramClass selectHost(
+      DexProgramClass class1, DexProgramClass class2, Set<DexType> hostsToAvoidIfPossible) {
+    boolean avoid1 = hostsToAvoidIfPossible.contains(class1.type);
+    boolean avoid2 = hostsToAvoidIfPossible.contains(class2.type);
+    if (avoid1 && !avoid2) {
+      return class2;
+    }
+    if (avoid2 && !avoid1) {
+      return class1;
+    }
+    int size1 = class1.getMethodCollection().size();
+    int size2 = class2.getMethodCollection().size();
+    if (size1 < size2) {
+      return class1;
+    }
+    if (size2 < size1) {
+      return class2;
+    }
+    assert class1.type != class2.type;
+    if (class1.type.slowCompareTo(class2.type) < 0) {
+      return class1;
+    }
+    return class2;
+  }
+
   private void updatePinnedItems(Set<DexType> enumsToUnbox) {
     appView
         .appInfo()
@@ -394,6 +481,85 @@
   }
 
   public void finishAnalysis() {
+    analyzeInitializers();
+    analyzeAccessibility();
+    if (debugLogEnabled) {
+      reportEnumsAnalysis();
+    }
+  }
+
+  private void analyzeAccessibility() {
+    // Unboxing an enum will require to move its methods to a different class, which may impact
+    // accessibility. For a quick analysis we simply reuse the inliner analysis.
+    for (DexType toUnbox : enumsUnboxingCandidates.keySet()) {
+      DexProgramClass enumClass = appView.definitionFor(toUnbox).asProgramClass();
+      Constraint classConstraint = analyzeAccessibilityInClass(enumClass);
+      if (classConstraint == Constraint.NEVER) {
+        markEnumAsUnboxable(Reason.ACCESSIBILITY, enumClass);
+      } else if (classConstraint == Constraint.PACKAGE) {
+        enumsToUnboxWithPackageRequirement.add(toUnbox);
+      }
+    }
+  }
+
+  private Constraint analyzeAccessibilityInClass(DexProgramClass enumClass) {
+    Constraint classConstraint = Constraint.ALWAYS;
+    for (DexEncodedMethod method : enumClass.methods()) {
+      // Enum initializer are analyzed in analyzeInitializers instead.
+      if (!method.isInitializer()) {
+        Constraint methodConstraint = constraintForEnumUnboxing(method);
+        classConstraint = meet(classConstraint, methodConstraint);
+        if (classConstraint == Constraint.NEVER) {
+          return classConstraint;
+        }
+      }
+    }
+    return classConstraint;
+  }
+
+  private Constraint meet(Constraint constraint1, Constraint constraint2) {
+    if (constraint1 == Constraint.NEVER || constraint2 == Constraint.NEVER) {
+      return Constraint.NEVER;
+    }
+    if (constraint1 == Constraint.ALWAYS) {
+      return constraint2;
+    }
+    if (constraint2 == Constraint.ALWAYS) {
+      return constraint1;
+    }
+    assert constraint1 == Constraint.PACKAGE && constraint2 == Constraint.PACKAGE;
+    return Constraint.PACKAGE;
+  }
+
+  public Constraint constraintForEnumUnboxing(DexEncodedMethod method) {
+    // TODO(b/160939354): Use a UseRegistry instead of inlining constraints.
+    assert appView.definitionForProgramType(method.holder()) != null;
+    assert appView.definitionForProgramType(method.holder()).isEnum();
+    assert appView.definitionForProgramType(method.holder()).isEffectivelyFinal(appView);
+    assert appView.definitionForProgramType(method.holder()).superType
+        == appView.dexItemFactory().enumType;
+    assert !appView.definitionForProgramType(method.holder()).isInANest()
+        : "Unboxable enum is in a nest, this should not happen in cf to dex compilation, R8 needs"
+            + " to take care of nest access control when relocating unboxable enums methods";
+    switch (method.getCompilationState()) {
+      case PROCESSED_INLINING_CANDIDATE_ANY:
+        return Constraint.ALWAYS;
+      case PROCESSED_INLINING_CANDIDATE_SAME_NEST:
+        assert false;
+        // fall through
+      case PROCESSED_INLINING_CANDIDATE_SUBCLASS:
+        // There is no such thing as subclass access in this context, enums analyzed here have no
+        // subclasses, inherit directly from java.lang.Enum and are not analyzed if they call
+        // the protected methods in java.lang.Enum and java.lang.Object.
+      case PROCESSED_INLINING_CANDIDATE_SAME_CLASS:
+      case PROCESSED_INLINING_CANDIDATE_SAME_PACKAGE:
+        return Constraint.PACKAGE;
+      default:
+        return Constraint.NEVER;
+    }
+  }
+
+  private void analyzeInitializers() {
     for (DexType toUnbox : enumsUnboxingCandidates.keySet()) {
       DexProgramClass enumClass = appView.definitionForProgramType(toUnbox);
       assert enumClass != null;
@@ -417,9 +583,6 @@
         markEnumAsUnboxable(Reason.INVALID_CLINIT, enumClass);
       }
     }
-    if (debugLogEnabled) {
-      reportEnumsAnalysis();
-    }
   }
 
   private Reason instructionAllowEnumUnboxing(
@@ -674,6 +837,7 @@
 
   public enum Reason {
     ELIGIBLE,
+    ACCESSIBILITY,
     ANNOTATION,
     PINNED,
     DOWN_CAST,
@@ -709,7 +873,8 @@
 
   private class TreeFixer {
 
-    private final List<DexEncodedMethod> unboxedEnumsMethods = new ArrayList<>();
+    private final Map<DexType, List<DexEncodedMethod>> unboxedEnumsMethods =
+        new IdentityHashMap<>();
     private final EnumUnboxingLens.Builder lensBuilder = EnumUnboxingLens.builder();
     private final Set<DexType> enumsToUnbox;
 
@@ -717,13 +882,13 @@
       this.enumsToUnbox = enumsToUnbox;
     }
 
-    private NestedGraphLens fixupTypeReferences() {
+    private NestedGraphLens fixupTypeReferences(Map<DexType, DexType> newMethodLocation) {
       assert enumUnboxerRewriter != null;
       // Fix all methods and fields using enums to unbox.
       for (DexProgramClass clazz : appView.appInfo().classes()) {
         if (enumsToUnbox.contains(clazz.type)) {
           assert clazz.instanceFields().size() == 0;
-          // Clear the initializers and move the static methods to the utility class.
+          // Clear the initializers and move the static methods to the new location.
           Set<DexEncodedMethod> methodsToRemove = Sets.newIdentityHashSet();
           clazz
               .methods()
@@ -732,8 +897,12 @@
                     if (m.isInitializer()) {
                       clearEnumToUnboxMethod(m);
                     } else {
-                      unboxedEnumsMethods.add(
-                          fixupEncodedMethodToUtility(m, factory.enumUnboxingUtilityType));
+                      DexType newHolder =
+                          newMethodLocation.getOrDefault(
+                              clazz.type, factory.enumUnboxingUtilityType);
+                      List<DexEncodedMethod> movedMethods =
+                          unboxedEnumsMethods.computeIfAbsent(newHolder, k -> new ArrayList<>());
+                      movedMethods.add(fixupEncodedMethodToUtility(m, newHolder));
                       methodsToRemove.add(m);
                     }
                   });
@@ -754,7 +923,11 @@
       DexProgramClass utilityClass =
           appView.definitionForProgramType(factory.enumUnboxingUtilityType);
       assert utilityClass != null : "Should have been synthesized upfront";
-      utilityClass.addDirectMethods(unboxedEnumsMethods);
+      unboxedEnumsMethods.forEach(
+          (newHolderType, movedMethods) -> {
+            DexProgramClass newHolderClass = appView.definitionFor(newHolderType).asProgramClass();
+            newHolderClass.addDirectMethods(movedMethods);
+          });
       return lensBuilder.build(factory, appView.graphLens(), enumsToUnbox);
     }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
index 617a12e..c4466cd 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizer.java
@@ -113,6 +113,11 @@
     this.converter = converter;
   }
 
+  // This set is an approximation and can be used only for heuristics.
+  public final Set<DexType> getCandidates() {
+    return candidates.keySet();
+  }
+
   // Before doing any usage-based analysis we collect a set of classes that can be
   // candidates for staticizing. This analysis is very simple, but minimizes the
   // set of eligible classes staticizer tracks and thus time and memory it needs.
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsAccessibilityErrorEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsAccessibilityErrorEnumUnboxingTest.java
new file mode 100644
index 0000000..52d8688
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsAccessibilityErrorEnumUnboxingTest.java
@@ -0,0 +1,101 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.enumunboxing;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.objectweb.asm.Opcodes.ACC_PRIVATE;
+import static org.objectweb.asm.Opcodes.ACC_STATIC;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.transformers.ClassTransformer;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.MethodVisitor;
+
+@RunWith(Parameterized.class)
+public class VirtualMethodsAccessibilityErrorEnumUnboxingTest extends EnumUnboxingTestBase {
+  private final TestParameters parameters;
+  private final boolean enumValueOptimization;
+  private final EnumKeepRules enumKeepRules;
+
+  @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+  public static List<Object[]> data() {
+    return enumUnboxingTestParameters();
+  }
+
+  public VirtualMethodsAccessibilityErrorEnumUnboxingTest(
+      TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+    this.parameters = parameters;
+    this.enumValueOptimization = enumValueOptimization;
+    this.enumKeepRules = enumKeepRules;
+  }
+
+  @Test
+  public void testEnumUnboxing() throws Exception {
+    byte[] testClassData =
+        transformer(TestClass.class)
+            .addClassTransformer(
+                new ClassTransformer() {
+                  @Override
+                  public MethodVisitor visitMethod(
+                      int access,
+                      String name,
+                      String descriptor,
+                      String signature,
+                      String[] exceptions) {
+                    if (name.equals("privateMethod")) {
+                      return super.visitMethod(
+                          ACC_STATIC | ACC_PRIVATE, name, descriptor, signature, exceptions);
+                    } else {
+                      return super.visitMethod(access, name, descriptor, signature, exceptions);
+                    }
+                  }
+                })
+            .transform();
+    testForR8(parameters.getBackend())
+        .noMinification()
+        .addProgramClasses(MyEnum.class)
+        .addProgramClassFileData(testClassData)
+        .addKeepMainRule(TestClass.class)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .allowDiagnosticInfoMessages()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertFailureWithErrorThatMatches(containsString("java.lang.IllegalAccessError"));
+  }
+
+  public static class TestClass {
+    // The method privateMethod will be transformed into a private method.
+    @NeverInline
+    protected static int privateMethod() {
+      return System.currentTimeMillis() > 0 ? 4 : 3;
+    }
+
+    public static void main(String[] args) {
+      System.out.println(MyEnum.A.ordinal());
+      MyEnum.print();
+    }
+  }
+
+  @NeverClassInline
+  enum MyEnum {
+    A,
+    B;
+
+    @NeverInline
+    static void print() {
+      // This should raise an accessibility error, weither the enum is unboxed or not.
+      System.out.println(TestClass.privateMethod());
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsEnumUnboxingTest.java
index 2e3466f..3a1fbab 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsEnumUnboxingTest.java
@@ -1,11 +1,8 @@
 // Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
-
 package com.android.tools.r8.enumunboxing;
 
-import static org.hamcrest.CoreMatchers.containsString;
-
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.R8TestCompileResult;
@@ -19,7 +16,6 @@
 
 @RunWith(Parameterized.class)
 public class VirtualMethodsEnumUnboxingTest extends EnumUnboxingTestBase {
-
   private final TestParameters parameters;
   private final boolean enumValueOptimization;
   private final EnumKeepRules enumKeepRules;
@@ -43,7 +39,6 @@
         testForR8(parameters.getBackend())
             .addInnerClasses(VirtualMethodsEnumUnboxingTest.class)
             .addKeepMainRule(classToTest)
-            .addKeepMainRule(VirtualMethodsFail.class)
             .addKeepRules(enumKeepRules.getKeepRules())
             .enableNeverClassInliningAnnotations()
             .enableInliningAnnotations()
@@ -58,13 +53,15 @@
                   assertEnumIsUnboxed(MyEnumWithCollisions.class, classToTest.getSimpleName(), m);
                   assertEnumIsUnboxed(
                       MyEnumWithPackagePrivateCall.class, classToTest.getSimpleName(), m);
+                  assertEnumIsUnboxed(
+                      MyEnumWithProtectedCall.class, classToTest.getSimpleName(), m);
+                  assertEnumIsUnboxed(
+                      MyEnumWithPackagePrivateFieldAccess.class, classToTest.getSimpleName(), m);
+                  assertEnumIsUnboxed(
+                      MyEnumWithPackagePrivateAndPrivateCall.class, classToTest.getSimpleName(), m);
                 });
     R8TestRunResult run = compile.run(parameters.getRuntime(), classToTest).assertSuccess();
     assertLines2By2Correct(run.getStdOut());
-    // TODO(b/160854837): This test should actually be successful.
-    compile
-        .run(parameters.getRuntime(), VirtualMethodsFail.class)
-        .assertFailureWithErrorThatMatches(containsString("IllegalAccessError"));
   }
 
   @SuppressWarnings("SameParameterValue")
@@ -110,7 +107,6 @@
       printPrivate();
     }
   }
-
   // Use two enums to test collision.
   @NeverClassInline
   enum MyEnum2 {
@@ -160,10 +156,30 @@
   }
 
   @NeverClassInline
-  static class PackagePrivateClass {
+  static class PackagePrivateClassWithPublicMembers {
+    @NeverInline
+    public static void print() {
+      System.out.println("print1");
+    }
+
+    public static int item = System.currentTimeMillis() > 0 ? 42 : 41;
+  }
+
+  @NeverClassInline
+  public static class PublicClassWithPackagePrivateMembers {
     @NeverInline
     static void print() {
-      System.out.println("print");
+      System.out.println("print2");
+    }
+
+    static int item = System.currentTimeMillis() > 0 ? 4 : 1;
+  }
+
+  @NeverClassInline
+  public static class PublicClassWithProtectedMembers {
+    @NeverInline
+    protected static void print() {
+      System.out.println("print3");
     }
   }
 
@@ -175,41 +191,75 @@
 
     @NeverInline
     public static void callPackagePrivate() {
-      PackagePrivateClass.print();
+      PackagePrivateClassWithPublicMembers.print();
+      System.out.println("print1");
+      PublicClassWithPackagePrivateMembers.print();
+      System.out.println("print2");
     }
   }
 
-  static class VirtualMethodsFail {
-    public static void main(String[] args) {
-      testCollisions();
-      testPackagePrivate();
+  @NeverClassInline
+  enum MyEnumWithPackagePrivateAndPrivateCall {
+    A,
+    B,
+    C;
+
+    @NeverInline
+    public static void privateMethod() {
+      System.out.println("private");
     }
 
     @NeverInline
-    private static void testPackagePrivate() {
-      System.out.println(MyEnumWithPackagePrivateCall.A.ordinal());
-      System.out.println(0);
-      MyEnumWithPackagePrivateCall.callPackagePrivate();
-      System.out.println("print");
+    public static void callPackagePrivateAndPrivate() {
+      // This method has "SAME_CLASS" as compilation state, yet,
+      // it also has a package-private call.
+      privateMethod();
+      System.out.println("private");
+      PackagePrivateClassWithPublicMembers.print();
+      System.out.println("print1");
+      PublicClassWithPackagePrivateMembers.print();
+      System.out.println("print2");
     }
+  }
+
+  @NeverClassInline
+  enum MyEnumWithProtectedCall {
+    A,
+    B,
+    C;
 
     @NeverInline
-    private static void testCollisions() {
-      System.out.println(MyEnumWithCollisions.A.get());
-      System.out.println(5);
-      System.out.println(MyEnumWithCollisions.B.get());
-      System.out.println(2);
-      System.out.println(MyEnumWithCollisions.C.get());
-      System.out.println(1);
+    public static void callProtected() {
+      PublicClassWithProtectedMembers.print();
+      System.out.println("print3");
+    }
+  }
+
+  @NeverClassInline
+  enum MyEnumWithPackagePrivateFieldAccess {
+    A,
+    B,
+    C;
+
+    @NeverInline
+    public static void accessPackagePrivate() {
+      System.out.println(PackagePrivateClassWithPublicMembers.item);
+      System.out.println("42");
+      System.out.println(PublicClassWithPackagePrivateMembers.item);
+      System.out.println("4");
     }
   }
 
   static class VirtualMethods {
-
     public static void main(String[] args) {
       testCustomMethods();
       testCustomMethods2();
       testNonPublicMethods();
+      testCollisions();
+      testPackagePrivateMethod();
+      testProtectedAccess();
+      testPackagePrivateAndPrivateMethod();
+      testPackagePrivateAccess();
     }
 
     @NeverInline
@@ -243,5 +293,43 @@
       System.out.println((MyEnum2.A.returnEnum(true).ordinal()));
       System.out.println(1);
     }
+
+    @NeverInline
+    private static void testPackagePrivateMethod() {
+      System.out.println(MyEnumWithPackagePrivateCall.A.ordinal());
+      System.out.println(0);
+      MyEnumWithPackagePrivateCall.callPackagePrivate();
+    }
+
+    @NeverInline
+    private static void testPackagePrivateAndPrivateMethod() {
+      System.out.println(MyEnumWithPackagePrivateAndPrivateCall.A.ordinal());
+      System.out.println(0);
+      MyEnumWithPackagePrivateAndPrivateCall.callPackagePrivateAndPrivate();
+    }
+
+    @NeverInline
+    private static void testPackagePrivateAccess() {
+      System.out.println(MyEnumWithPackagePrivateFieldAccess.A.ordinal());
+      System.out.println(0);
+      MyEnumWithPackagePrivateFieldAccess.accessPackagePrivate();
+    }
+
+    @NeverInline
+    private static void testProtectedAccess() {
+      System.out.println(MyEnumWithProtectedCall.A.ordinal());
+      System.out.println(0);
+      MyEnumWithProtectedCall.callProtected();
+    }
+
+    @NeverInline
+    private static void testCollisions() {
+      System.out.println(MyEnumWithCollisions.A.get());
+      System.out.println(5);
+      System.out.println(MyEnumWithCollisions.B.get());
+      System.out.println(2);
+      System.out.println(MyEnumWithCollisions.C.get());
+      System.out.println(1);
+    }
   }
 }