--- /dev/null	2013-10-23 13:21:49.554975487 -0700
+++ new/src/share/classes/java/lang/reflect/AnnotatedElementSupport.java	2013-10-25 00:51:26.000000000 -0700
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.lang.reflect;
+
+import java.lang.annotation.*;
+import java.util.Objects;
+import sun.reflect.annotation.AnnotationSupport;
+import sun.reflect.annotation.AnnotationType;
+
+/**
+ * This class provides static utility methods to be called by
+ * implementations of {@link AnnotatedElement}, including the default
+ * methods in that interface.
+ */
+class AnnotatedElementSupport {
+    public static <T extends Annotation> T[] getAnnotationsByTypeDeclaredOrNot(AnnotatedElement element,
+                                                                               Class<T> annotationClass,
+                                                                               boolean declared) {
+        // First do get-declared-annotations-by-type...
+        declared = true; // TODO : change this
+
+        // TODO: probably should call getDeclaredAnnotations once and
+        // then look for an annotation and its container, if any, in
+        // that array :-(
+
+        Objects.requireNonNull(annotationClass);
+        int resultSize = 0;
+        T directlyPresent = element.getDeclaredAnnotation(annotationClass);
+        @SuppressWarnings("unchecked")
+        T[] indirectlyPresent =  (T[]) Array.newInstance(annotationClass, 0);
+
+        if (directlyPresent != null) {
+            resultSize++;
+        }
+
+        // If the annotation type is repeatable, look through a
+        // container if one is present
+        Repeatable repeatable = annotationClass.getAnnotation(Repeatable.class);
+        Class<? extends Annotation> containerType = null;
+        if (repeatable != null) { // T is a repeatable annotation type
+            containerType = repeatable.value();
+            Annotation container =  element.getDeclaredAnnotation(containerType);
+            if (container != null) {
+                indirectlyPresent = AnnotationSupport.getValueArray(container);
+                resultSize += indirectlyPresent.length;
+            }
+        }
+    
+        if (resultSize == indirectlyPresent.length) {
+            assert resultSize == 0 || directlyPresent == null;
+            /*
+             * If resultSize is 0, indirectlyPresent is either
+             * assigned to the result of the initial Array.newInstance
+             * call or indirectlyPresent is assigned to a zero-lenght
+             * value array from an empty container annotation. In
+             * either case, a zero-length array is immutable and does
+             * not need to reallocated before being returned.
+             *
+             * If resultSize is nonzero, then indirectlyPresent points
+             * to the result calling a method on an annotation and
+             * annotations are required to implement a no sharing
+             * policy. Therefore, it is not required to copy the
+             * elements of indirectlyPresent into a new array of the
+             * same size.
+             */
+            return indirectlyPresent;
+        } else {
+            assert resultSize > 0 && (directlyPresent != null || indirectlyPresent.length > 0);
+            @SuppressWarnings("unchecked")
+            T[] returnValue = (T[]) Array.newInstance(annotationClass, resultSize);
+
+            if (indirectlyPresent.length == 0) {
+                assert resultSize == 1;
+                returnValue[0] = directlyPresent;
+            } else {
+                assert directlyPresent != null  && indirectlyPresent.length > 0;
+                // Determine whether the directly present annotation
+                // comes before or after the indirectly present ones.
+
+                int indirectOffset = 0;
+
+                for (Annotation a : element.getDeclaredAnnotations()) {
+                    if (a.annotationType().equals(annotationClass)) {
+                        indirectOffset = 1;
+                        break;
+                    } else if (a.annotationType().equals(containerType)) {
+                        break;
+                    }
+                }
+
+                for (int i = 0; i < resultSize; i++) {
+                    returnValue[i + indirectOffset] = indirectlyPresent[i];
+                }
+
+                returnValue[(indirectOffset == 1) ? 0 : resultSize - 1] = directlyPresent;
+            }
+            return returnValue;
+        }
+    }
+}