diff --git a/luni/src/main/java/libcore/reflect/AnnotatedElements.java b/luni/src/main/java/libcore/reflect/AnnotatedElements.java
deleted file mode 100644
index 2fe2d2b..0000000
--- a/luni/src/main/java/libcore/reflect/AnnotatedElements.java
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * 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 libcore.reflect;
-
-import java.lang.annotation.Annotation;
-import java.lang.annotation.IncompleteAnnotationException;
-import java.lang.annotation.Repeatable;
-import java.lang.reflect.*;
-import java.util.ArrayList;
-
-/**
- * Implementation of {@link AnnotatedElement}'s 1.8 methods.
- *
- * <p>This implementation is shared between all the classes implementing {@link AnnotatedElement},
- * avoiding code duplication.</p>
- *
- * @hide
- */
-public final class AnnotatedElements {
-  /**
-   * Default implementation for {@link AnnotatedElement#getDeclaredAnnotation}.
-   *
-   * @return Directly present annotation of type {@code annotationClass} for {@code element},
-   *         or {@code null} if none was found.
-   */
-  public static <T extends Annotation> T getDeclaredAnnotation(AnnotatedElement element,
-      Class<T> annotationClass) {
-    if (annotationClass == null) {
-      throw new NullPointerException("annotationClass");
-    }
-
-    Annotation[] annotations = element.getDeclaredAnnotations();
-
-    // Safeguard: getDeclaredAnnotations should never return null.
-    if (annotations == null) {
-      return null;
-    }
-
-    // The annotation might be directly present:
-    // Return the first (and only) annotation whose class matches annotationClass.
-    for (int i = 0; i < annotations.length; ++i) {
-      if (annotationClass.isInstance(annotations[i])) {
-        return (T)annotations[i];  // Safe because of above guard.
-      }
-    }
-
-    // The annotation was *not* directly present:
-    // If the array was empty, or we found no matches, return null.
-    return null;
-  }
-
-  /**
-   * Default implementation for {@link AnnotatedElement#getDeclaredAnnotationsByType}.
-   *
-   * @return Directly/indirectly present list of annotations of type {@code annotationClass} for
-   *         {@code element}, or an empty array if none were found.
-   */
-  public static <T extends Annotation> T[] getDeclaredAnnotationsByType(AnnotatedElement element,
-      Class<T> annotationClass) {
-    if (annotationClass == null) {
-      throw new NullPointerException("annotationClass");
-    }
-
-    Annotation[] annotations = element.getDeclaredAnnotations();
-
-    // Store a list of repeatable annotations that have been extracted from their container.
-    ArrayList<T> unfoldedAnnotations = new ArrayList<T>();
-
-    Class<? extends Annotation> repeatableAnnotationClass =
-        getRepeatableAnnotationContainerClassFor(annotationClass);
-
-    for (int i = 0; i < annotations.length; ++i) {
-      if (annotationClass.isInstance(annotations[i])) {
-        // Is it directly present?
-        unfoldedAnnotations.add((T)annotations[i]);  // Safe, guarded by above check.
-      } else if (repeatableAnnotationClass != null &&
-          repeatableAnnotationClass.isInstance(annotations[i])) {
-        // Is it repeatably (indirectly) present?
-        insertAnnotationValues(annotations[i], annotationClass, unfoldedAnnotations);
-      }
-    }
-
-    return unfoldedAnnotations.toArray((T[])Array.newInstance(annotationClass, 0));
-  }
-
-  /**
-   * Extracts annotations from a container annotation and inserts them into a list.
-   *
-   * <p>
-   * Given a complex annotation "annotation", it should have a "T[] value()" method on it.
-   * Call that method and add all of the nested annotations into unfoldedAnnotations list.
-   * </p>
-   */
-  private static <T extends Annotation> void insertAnnotationValues(Annotation annotation,
-      Class<T> annotationClass, ArrayList<T> unfoldedAnnotations) {
-    // annotation is a complex annotation which has elements of instance annotationClass
-    // (whose static type is T).
-    //
-    // @interface SomeName {  <--- = annotation.getClass()
-    //   ...
-    //   T[] value();        <--- T.class == annotationClass
-    // }
-    //
-    // Use reflection to access these values.
-    Class<T[]> annotationArrayClass =
-        (Class<T[]>)((T[])Array.newInstance(annotationClass, 0)).getClass();
-
-    Method valuesMethod;
-    try {
-      valuesMethod = annotation.getClass().getDeclaredMethod("value");
-      // This will always succeed unless the annotation and its repeatable annotation class were
-      // recompiled separately, then this is a binary incompatibility error.
-    } catch (NoSuchMethodException e) {
-      throw new AssertionError("annotation container = " + annotation +
-          "annotation element class = " + annotationClass + "; missing value() method");
-    } catch (SecurityException e) {
-      throw new IncompleteAnnotationException(annotation.getClass(), "value");
-    }
-
-    // Ensure that value() returns a T[]
-    if (!valuesMethod.getReturnType().isArray()) {
-      throw new AssertionError("annotation container = " + annotation +
-          "annotation element class = " + annotationClass + "; value() doesn't return array");
-    }
-
-    // Ensure that the T[] value() is actually the correct type (T==annotationClass).
-    if (!annotationClass.equals(valuesMethod.getReturnType().getComponentType())) {
-      throw new AssertionError("annotation container = " + annotation +
-          "annotation element class = " + annotationClass + "; value() returns incorrect type");
-    }
-
-    // Append those values into the existing list.
-    T[] nestedAnnotations;
-    try {
-      nestedAnnotations = (T[])valuesMethod.invoke(annotation);  // Safe because of #getMethod.
-    } catch (IllegalAccessException|InvocationTargetException e) {
-      throw new AssertionError(e);
-    }
-
-    for (int i = 0; i < nestedAnnotations.length; ++i) {
-      unfoldedAnnotations.add(nestedAnnotations[i]);
-    }
-  }
-
-  /**
-   * Find the {@code \@Repeatable} container annotation class for an annotation class, or
-   * {@code null}.
-   *
-   * <p>
-   * Given:
-   *
-   * <code>
-   *  @Repeatable(X.class)
-   *  @interface SomeName {     <--- = annotationClass
-   *  }...
-   * </code>
-   *
-   * <p>
-   * Returns {@code X.class}
-   *
-   * Otherwise if there was no {@code \@Repeatable} annotation, return {@code null}.
-   * </p>
-   */
-  private static <T extends Annotation> Class<? extends Annotation>
-      getRepeatableAnnotationContainerClassFor(Class<T> annotationClass) {
-
-    Repeatable repeatableAnnotation = annotationClass.getDeclaredAnnotation(Repeatable.class);
-    return (repeatableAnnotation == null) ? null : repeatableAnnotation.value();
-  }
-
-  /**
-   * Default implementation of {@link AnnotatedElement#getAnnotationsByType}.
-   *
-   * <p>
-   * This method does not handle inherited annotations and is
-   * intended for use for {@code Method}, {@code Field}, {@code Package}.
-   * The {@link Class#getAnnotationsByType} is implemented explicitly.
-   * </p>
-   *
-   * @return Associated annotations of type {@code annotationClass} for {@code element}.
-   */
-  public static <T extends Annotation> T[] getAnnotationsByType(AnnotatedElement element,
-      Class<T> annotationClass) {
-    if (annotationClass == null) {
-      throw new NullPointerException("annotationClass");
-    }
-
-    // Find any associated annotations [directly or repeatably (indirectly) present on this class].
-    T[] annotations = element.getDeclaredAnnotationsByType(annotationClass);
-    if (annotations == null) {
-      throw new AssertionError("annotations must not be null");  // Internal error.
-    }
-
-    // If nothing was found, we would look for associated annotations recursively up to the root
-    // class. However this can only happen if AnnotatedElement is a Class, which is handled
-    // in the Class override of this method.
-    return annotations;
-  }
-
-  private AnnotatedElements() {
-    throw new AssertionError("Instances of AnnotatedElements not allowed");
-  }
-}
-
diff --git a/non_openjdk_java_files.mk b/non_openjdk_java_files.mk
index 856a3255..34d9aab9 100644
--- a/non_openjdk_java_files.mk
+++ b/non_openjdk_java_files.mk
@@ -381,7 +381,6 @@
   luni/src/main/java/libcore/net/event/NetworkEventListener.java \
   luni/src/main/java/libcore/net/http/HttpDate.java \
   luni/src/main/java/libcore/net/http/ResponseUtils.java \
-  luni/src/main/java/libcore/reflect/AnnotatedElements.java \
   luni/src/main/java/libcore/reflect/AnnotationAccess.java \
   luni/src/main/java/libcore/reflect/AnnotationFactory.java \
   luni/src/main/java/libcore/reflect/AnnotationMember.java \
diff --git a/ojluni/src/main/java/java/lang/Class.java b/ojluni/src/main/java/java/lang/Class.java
index de378da..e952660 100755
--- a/ojluni/src/main/java/java/lang/Class.java
+++ b/ojluni/src/main/java/java/lang/Class.java
@@ -65,7 +65,6 @@
 import java.lang.reflect.AccessibleObject;
 import com.android.dex.Dex;
 import dalvik.system.VMStack;
-import libcore.reflect.AnnotatedElements;
 import libcore.reflect.AnnotationAccess;
 import libcore.reflect.InternalNames;
 import libcore.reflect.GenericSignatureParser;
@@ -2466,56 +2465,9 @@
     @Override public native Annotation[] getDeclaredAnnotations();
 
     /**
-     * {@inheritDoc}
-     * @since 1.8
-     * @hide 1.8
+     * Returns the annotation if it exists.
      */
-    @Override
-    public <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
-      return AnnotatedElements.getDeclaredAnnotationsByType(this, annotationClass);
-    }
-
-    /**
-     * {@inheritDoc}
-     * @since 1.8
-     * @hide 1.8
-     */
-    @Override
-    public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
-      // Find any associated annotations [directly or repeatably (indirectly) present on this].
-      T[] annotations = AnnotatedElements.getAnnotationsByType(this, annotationClass);
-
-      if (annotations.length != 0) {
-        return annotations;
-      }
-
-      // Nothing was found, attempt looking for associated annotations recursively up to the root
-      // class if and only if:
-      // * The annotation class was marked with @Inherited.
-      //
-      // Inherited annotations are not coalesced into a single set: the first declaration found is
-      // returned.
-
-      if (annotationClass.isDeclaredAnnotationPresent(Inherited.class)) {
-        Class<?> superClass = getSuperclass();  // Returns null if klass's base is Object.
-
-        if (superClass != null) {
-          return superClass.getAnnotationsByType(annotationClass);
-        }
-      }
-
-      // Annotated was not marked with @Inherited, or no superclass.
-      return (T[]) Array.newInstance(annotationClass, 0);  // Safe by construction.
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * @since 1.8
-     * @hide 1.8
-     */
-    @Override
-    public native <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass);
+    private native <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass);
 
     /**
      * Returns true if the annotation exists.
diff --git a/ojluni/src/main/java/java/lang/Package.java b/ojluni/src/main/java/java/lang/Package.java
index 4fbbf29..0b1a036 100755
--- a/ojluni/src/main/java/java/lang/Package.java
+++ b/ojluni/src/main/java/java/lang/Package.java
@@ -53,8 +53,6 @@
 import sun.reflect.CallerSensitive;
 import dalvik.system.VMStack;
 
-import libcore.reflect.AnnotatedElements;
-
 /**
  * {@code Package} objects contain version information
  * about the implementation and specification of a Java package.
@@ -415,35 +413,6 @@
     }
 
     /**
-     * {@inheritDoc}
-     * @since 1.8
-     * @hide 1.8
-     */
-    @Override
-    public <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
-      return AnnotatedElements.getDeclaredAnnotationsByType(this, annotationClass);
-    }
-
-    /**
-     * {@inheritDoc}
-     * @since 1.8
-     * @hide 1.8
-     */
-    @Override
-    public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
-      return AnnotatedElements.getAnnotationsByType(this, annotationClass);
-    }
-
-    /**
-     * {@inheritDoc}
-     * @since 1.8
-     * @hide 1.8
-     */
-    @Override
-    public <T extends Annotation> Annotation getDeclaredAnnotation(Class<T> annotationClass) {
-      return AnnotatedElements.getDeclaredAnnotation(this, annotationClass);
-    }
-    /**
      * Construct a package instance with the specified version
      * information.
      * @param pkgName the name of the package
diff --git a/ojluni/src/main/java/java/lang/reflect/AccessibleObject.java b/ojluni/src/main/java/java/lang/reflect/AccessibleObject.java
index 68c8555..b7ace79 100755
--- a/ojluni/src/main/java/java/lang/reflect/AccessibleObject.java
+++ b/ojluni/src/main/java/java/lang/reflect/AccessibleObject.java
@@ -30,8 +30,6 @@
 import sun.reflect.Reflection;
 import java.lang.annotation.Annotation;
 
-import libcore.reflect.AnnotatedElements;
-
 /**
  * The AccessibleObject class is the base class for Field, Method and
  * Constructor objects.  It provides the ability to flag a reflected
@@ -195,34 +193,4 @@
     public Annotation[] getDeclaredAnnotations()  {
         throw new AssertionError("All subclasses should override this method");
     }
-
-    /**
-     * {@inheritDoc}
-     * @since 1.8
-     * @hide 1.8
-     */
-    @Override
-    public <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
-      return AnnotatedElements.getDeclaredAnnotationsByType(this, annotationClass);
-    }
-
-    /**
-     * {@inheritDoc}
-     * @since 1.8
-     * @hide 1.8
-     */
-    @Override
-    public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
-      return AnnotatedElements.getAnnotationsByType(this, annotationClass);
-    }
-
-    /**
-     * {@inheritDoc}
-     * @since 1.8
-     * @hide 1.8
-     */
-    @Override
-    public <T extends Annotation> Annotation getDeclaredAnnotation(Class<T> annotationClass) {
-      return AnnotatedElements.getDeclaredAnnotation(this, annotationClass);
-    }
 }
diff --git a/ojluni/src/main/java/java/lang/reflect/AnnotatedElement.java b/ojluni/src/main/java/java/lang/reflect/AnnotatedElement.java
index b67b801..dc24483 100755
--- a/ojluni/src/main/java/java/lang/reflect/AnnotatedElement.java
+++ b/ojluni/src/main/java/java/lang/reflect/AnnotatedElement.java
@@ -1,5 +1,4 @@
 /*
- * Copyright (C) 2016 The Android Open Source Project
  * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -27,7 +26,6 @@
 package java.lang.reflect;
 
 import java.lang.annotation.Annotation;
-// import libcore.reflect.AnnotatedElements;
 
 /**
  * Represents an annotated element of the program currently running in this
@@ -73,8 +71,7 @@
      * @throws NullPointerException if the given annotation class is null
      * @since 1.5
      */
-     /*default*/ boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);
-     // { return getAnnotation(annotationClass) != null; }
+     boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);
 
    /**
      * Returns this element's annotation for the specified type if
@@ -112,34 +109,4 @@
      * @since 1.5
      */
     Annotation[] getDeclaredAnnotations();
-
-    /**
-     * Returns a directly-present annotation on {@code this} element, whose class is
-     * {@code annotationClass}, or {@code null} if nothing was found.
-     *
-     * @since 1.8
-     * @hide 1.8
-     */
-    /*default*/ <T extends Annotation> Annotation getDeclaredAnnotation(Class<T> annotationClass);
-    // { return AnnotatedElements.getDeclaredAnnotation(this, annotationClass); }
-
-    /**
-     * Returns a directly or indirectly present list of annotations on {@code this} element,
-     * whose class is {@code annotationClass}, or an empty array if nothing was found.
-     *
-     * @since 1.8
-     * @hide 1.8
-     */
-    /*default*/ <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass);
-    // { return AnnotatedElements.getDeclaredAnnotationsByType(this, annotationClass); }
-
-    /**
-     * Returns an associated list of annotations on {@code this} element,
-     * whose class is {@code annotationClass}, or an empty array if nothing was found.
-     *
-     * @since 1.8
-     * @hide 1.8
-     */
-    /*default*/ <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass);
-    // { return AnnotatedElements.getAnnotationsByType(this, annotationClass); }
 }