--- old/src/java.base/share/classes/java/lang/reflect/Constructor.java	2017-05-17 15:52:05.765714343 -0700
+++ new/src/java.base/share/classes/java/lang/reflect/Constructor.java	2017-05-17 15:52:05.605634350 -0700
@@ -588,19 +588,18 @@
     }
 
     @Override
-    void handleParameterNumberMismatch(int resultLength, int numParameters) {
+    boolean handleParameterNumberMismatch(int resultLength, int numParameters) {
         Class<?> declaringClass = getDeclaringClass();
         if (declaringClass.isEnum() ||
             declaringClass.isAnonymousClass() ||
             declaringClass.isLocalClass() )
-            return ; // Can't do reliable parameter counting
+            return false; // Can't do reliable parameter counting
         else {
-            if (!declaringClass.isMemberClass() || // top-level
-                // Check for the enclosing instance parameter for
-                // non-static member classes
-                (declaringClass.isMemberClass() &&
-                 ((declaringClass.getModifiers() & Modifier.STATIC) == 0)  &&
-                 resultLength + 1 != numParameters) ) {
+            if (declaringClass.isMemberClass() &&
+                ((declaringClass.getModifiers() & Modifier.STATIC) == 0)  &&
+                resultLength + 1 == numParameters) {
+                return true;
+            } else {
                 throw new AnnotationFormatError(
                           "Parameter annotations don't match number of parameters");
             }
--- old/src/java.base/share/classes/java/lang/reflect/Executable.java	2017-05-17 15:52:06.233948324 -0700
+++ new/src/java.base/share/classes/java/lang/reflect/Executable.java	2017-05-17 15:52:06.073868330 -0700
@@ -545,18 +545,28 @@
 
     Annotation[][] sharedGetParameterAnnotations(Class<?>[] parameterTypes,
                                                  byte[] parameterAnnotations) {
+        // System.out.println("\t Calling sharedGetParameterAnnotations");
         int numParameters = parameterTypes.length;
         if (parameterAnnotations == null)
             return new Annotation[numParameters][0];
 
         Annotation[][] result = parseParameterAnnotations(parameterAnnotations);
+        // System.out.println("\t" + java.util.Arrays.deepToString(result));
 
-        if (result.length != numParameters)
-            handleParameterNumberMismatch(result.length, numParameters);
+        //System.out.println("\tresult.length " +
+        //                   result.length + "\tnumParameters " + numParameters);
+        if (result.length != numParameters &&
+            handleParameterNumberMismatch(result.length, numParameters)) {
+            Annotation[][] tmp = new Annotation[result.length+1][];
+            // Shift annotations down one to account for an implicit leading parameter
+            System.arraycopy(result, 0, tmp, 1, result.length);
+            tmp[0] = new Annotation[0];
+            result = tmp;
+        }
         return result;
     }
 
-    abstract void handleParameterNumberMismatch(int resultLength, int numParameters);
+    abstract boolean handleParameterNumberMismatch(int resultLength, int numParameters);
 
     /**
      * {@inheritDoc}
--- old/src/java.base/share/classes/java/lang/reflect/Method.java	2017-05-17 15:52:06.678170305 -0700
+++ new/src/java.base/share/classes/java/lang/reflect/Method.java	2017-05-17 15:52:06.558110310 -0700
@@ -719,7 +719,7 @@
     }
 
     @Override
-    void handleParameterNumberMismatch(int resultLength, int numParameters) {
+    boolean handleParameterNumberMismatch(int resultLength, int numParameters) {
         throw new AnnotationFormatError("Parameter annotations don't match number of parameters");
     }
 }
--- old/src/java.base/share/classes/sun/reflect/annotation/TypeAnnotationParser.java	2017-05-17 15:52:07.098380286 -0700
+++ new/src/java.base/share/classes/sun/reflect/annotation/TypeAnnotationParser.java	2017-05-17 15:52:06.958310292 -0700
@@ -123,9 +123,30 @@
                 tmp.add(t);
             }
         }
+        // If a constructor has a mandated outer this, it has no
+        // annotations and the annotations to parameter mapping should
+        // be offset by 1.
+        boolean offset = false;
+        if (decl instanceof Constructor) {
+            Constructor<?> ctor = (Constructor<?>) decl;
+            Class<?> declaringClass = ctor.getDeclaringClass();
+            if (!declaringClass.isEnum() &&
+                (declaringClass.isMemberClass() &&
+                 (declaringClass.getModifiers() & Modifier.STATIC) == 0) ) {
+                }
+            offset = true;
+        }
         for (int i = 0; i < size; i++) {
-            @SuppressWarnings("unchecked")
-            ArrayList<TypeAnnotation> list = l[i];
+            ArrayList<TypeAnnotation> list;
+            if (offset) {
+                @SuppressWarnings("unchecked")
+                ArrayList<TypeAnnotation> tmp = (i == 0) ? null : l[i - 1];
+                list = tmp;
+            } else {
+                @SuppressWarnings("unchecked")
+                ArrayList<TypeAnnotation> tmp = l[i];
+                list = tmp;
+            }
             TypeAnnotation[] typeAnnotations;
             if (list != null) {
                 typeAnnotations = list.toArray(new TypeAnnotation[list.size()]);