1 /*
   2  * Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.lang.reflect;
  27 
  28 import jdk.internal.HotSpotIntrinsicCandidate;
  29 import jdk.internal.misc.SharedSecrets;
  30 import jdk.internal.reflect.CallerSensitive;
  31 import jdk.internal.reflect.MethodAccessor;
  32 import jdk.internal.reflect.Reflection;
  33 import jdk.internal.vm.annotation.ForceInline;
  34 import sun.reflect.annotation.ExceptionProxy;
  35 import sun.reflect.annotation.TypeNotPresentExceptionProxy;
  36 import sun.reflect.generics.repository.MethodRepository;
  37 import sun.reflect.generics.factory.CoreReflectionFactory;
  38 import sun.reflect.generics.factory.GenericsFactory;
  39 import sun.reflect.generics.scope.MethodScope;
  40 import sun.reflect.annotation.AnnotationType;
  41 import sun.reflect.annotation.AnnotationParser;
  42 import java.lang.annotation.Annotation;
  43 import java.lang.annotation.AnnotationFormatError;
  44 import java.nio.ByteBuffer;
  45 import java.util.StringJoiner;
  46 
  47 /**
  48  * A {@code Method} provides information about, and access to, a single method
  49  * on a class or interface.  The reflected method may be a class method
  50  * or an instance method (including an abstract method).
  51  *
  52  * <p>A {@code Method} permits widening conversions to occur when matching the
  53  * actual parameters to invoke with the underlying method's formal
  54  * parameters, but it throws an {@code IllegalArgumentException} if a
  55  * narrowing conversion would occur.
  56  *
  57  * @see Member
  58  * @see java.lang.Class
  59  * @see java.lang.Class#getMethods()
  60  * @see java.lang.Class#getMethod(String, Class[])
  61  * @see java.lang.Class#getDeclaredMethods()
  62  * @see java.lang.Class#getDeclaredMethod(String, Class[])
  63  *
  64  * @author Kenneth Russell
  65  * @author Nakul Saraiya
  66  * @since 1.1
  67  */
  68 public final class Method extends Executable {
  69     private Class<?>            clazz;
  70     private int                 slot;
  71     // This is guaranteed to be interned by the VM in the 1.4
  72     // reflection implementation
  73     private String              name;
  74     private Class<?>            returnType;
  75     private Class<?>[]          parameterTypes;
  76     private Class<?>[]          exceptionTypes;
  77     private int                 modifiers;
  78     // Generics and annotations support
  79     private transient String              signature;
  80     // generic info repository; lazily initialized
  81     private transient MethodRepository genericInfo;
  82     private byte[]              annotations;
  83     private byte[]              parameterAnnotations;
  84     private byte[]              annotationDefault;
  85     private volatile MethodAccessor methodAccessor;
  86     // For sharing of MethodAccessors. This branching structure is
  87     // currently only two levels deep (i.e., one root Method and
  88     // potentially many Method objects pointing to it.)
  89     //
  90     // If this branching structure would ever contain cycles, deadlocks can
  91     // occur in annotation code.
  92     private Method              root;
  93 
  94     // Generics infrastructure
  95     private String getGenericSignature() {return signature;}
  96 
  97     // Accessor for factory
  98     private GenericsFactory getFactory() {
  99         // create scope and factory
 100         return CoreReflectionFactory.make(this, MethodScope.make(this));
 101     }
 102 
 103     // Accessor for generic info repository
 104     @Override
 105     MethodRepository getGenericInfo() {
 106         // lazily initialize repository if necessary
 107         if (genericInfo == null) {
 108             // create and cache generic info repository
 109             genericInfo = MethodRepository.make(getGenericSignature(),
 110                                                 getFactory());
 111         }
 112         return genericInfo; //return cached repository
 113     }
 114 
 115     /**
 116      * Package-private constructor used by ReflectAccess to enable
 117      * instantiation of these objects in Java code from the java.lang
 118      * package via sun.reflect.LangReflectAccess.
 119      */
 120     Method(Class<?> declaringClass,
 121            String name,
 122            Class<?>[] parameterTypes,
 123            Class<?> returnType,
 124            Class<?>[] checkedExceptions,
 125            int modifiers,
 126            int slot,
 127            String signature,
 128            byte[] annotations,
 129            byte[] parameterAnnotations,
 130            byte[] annotationDefault) {
 131         this.clazz = declaringClass;
 132         this.name = name;
 133         this.parameterTypes = parameterTypes;
 134         this.returnType = returnType;
 135         this.exceptionTypes = checkedExceptions;
 136         this.modifiers = modifiers;
 137         this.slot = slot;
 138         this.signature = signature;
 139         this.annotations = annotations;
 140         this.parameterAnnotations = parameterAnnotations;
 141         this.annotationDefault = annotationDefault;
 142     }
 143 
 144     /**
 145      * Package-private routine (exposed to java.lang.Class via
 146      * ReflectAccess) which returns a copy of this Method. The copy's
 147      * "root" field points to this Method.
 148      */
 149     Method copy() {
 150         // This routine enables sharing of MethodAccessor objects
 151         // among Method objects which refer to the same underlying
 152         // method in the VM. (All of this contortion is only necessary
 153         // because of the "accessibility" bit in AccessibleObject,
 154         // which implicitly requires that new java.lang.reflect
 155         // objects be fabricated for each reflective call on Class
 156         // objects.)
 157         if (this.root != null)
 158             throw new IllegalArgumentException("Can not copy a non-root Method");
 159 
 160         Method res = new Method(clazz, name, parameterTypes, returnType,
 161                                 exceptionTypes, modifiers, slot, signature,
 162                                 annotations, parameterAnnotations, annotationDefault);
 163         res.root = this;
 164         // Might as well eagerly propagate this if already present
 165         res.methodAccessor = methodAccessor;
 166         return res;
 167     }
 168 
 169     /**
 170      * Make a copy of a leaf method.
 171      */
 172     Method leafCopy() {
 173         if (this.root == null)
 174             throw new IllegalArgumentException("Can only leafCopy a non-root Method");
 175 
 176         Method res = new Method(clazz, name, parameterTypes, returnType,
 177                 exceptionTypes, modifiers, slot, signature,
 178                 annotations, parameterAnnotations, annotationDefault);
 179         res.root = root;
 180         res.methodAccessor = methodAccessor;
 181         return res;
 182     }
 183 
 184     /**
 185      * @throws InaccessibleObjectException {@inheritDoc}
 186      * @throws SecurityException {@inheritDoc}
 187      */
 188     @Override
 189     @CallerSensitive
 190     public void setAccessible(boolean flag) {
 191         AccessibleObject.checkPermission();
 192         if (flag) checkCanSetAccessible(Reflection.getCallerClass());
 193         setAccessible0(flag);
 194     }
 195 
 196     @Override
 197     void checkCanSetAccessible(Class<?> caller) {
 198         checkCanSetAccessible(caller, clazz);
 199     }
 200 
 201     /**
 202      * Used by Excecutable for annotation sharing.
 203      */
 204     @Override
 205     Executable getRoot() {
 206         return root;
 207     }
 208 
 209     @Override
 210     boolean hasGenericInformation() {
 211         return (getGenericSignature() != null);
 212     }
 213 
 214     @Override
 215     byte[] getAnnotationBytes() {
 216         return annotations;
 217     }
 218 
 219     /**
 220      * Returns the {@code Class} object representing the class or interface
 221      * that declares the method represented by this object.
 222      */
 223     @Override
 224     public Class<?> getDeclaringClass() {
 225         return clazz;
 226     }
 227 
 228     /**
 229      * Returns the name of the method represented by this {@code Method}
 230      * object, as a {@code String}.
 231      */
 232     @Override
 233     public String getName() {
 234         return name;
 235     }
 236 
 237     /**
 238      * {@inheritDoc}
 239      */
 240     @Override
 241     public int getModifiers() {
 242         return modifiers;
 243     }
 244 
 245     /**
 246      * {@inheritDoc}
 247      * @throws GenericSignatureFormatError {@inheritDoc}
 248      * @since 1.5
 249      */
 250     @Override
 251     @SuppressWarnings({"rawtypes", "unchecked"})
 252     public TypeVariable<Method>[] getTypeParameters() {
 253         if (getGenericSignature() != null)
 254             return (TypeVariable<Method>[])getGenericInfo().getTypeParameters();
 255         else
 256             return (TypeVariable<Method>[])new TypeVariable[0];
 257     }
 258 
 259     /**
 260      * Returns a {@code Class} object that represents the formal return type
 261      * of the method represented by this {@code Method} object.
 262      *
 263      * @return the return type for the method this object represents
 264      */
 265     public Class<?> getReturnType() {
 266         return returnType;
 267     }
 268 
 269     /**
 270      * Returns a {@code Type} object that represents the formal return
 271      * type of the method represented by this {@code Method} object.
 272      *
 273      * <p>If the return type is a parameterized type,
 274      * the {@code Type} object returned must accurately reflect
 275      * the actual type parameters used in the source code.
 276      *
 277      * <p>If the return type is a type variable or a parameterized type, it
 278      * is created. Otherwise, it is resolved.
 279      *
 280      * @return  a {@code Type} object that represents the formal return
 281      *     type of the underlying  method
 282      * @throws GenericSignatureFormatError
 283      *     if the generic method signature does not conform to the format
 284      *     specified in
 285      *     <cite>The Java&trade; Virtual Machine Specification</cite>
 286      * @throws TypeNotPresentException if the underlying method's
 287      *     return type refers to a non-existent type declaration
 288      * @throws MalformedParameterizedTypeException if the
 289      *     underlying method's return typed refers to a parameterized
 290      *     type that cannot be instantiated for any reason
 291      * @since 1.5
 292      */
 293     public Type getGenericReturnType() {
 294       if (getGenericSignature() != null) {
 295         return getGenericInfo().getReturnType();
 296       } else { return getReturnType();}
 297     }
 298 
 299     @Override
 300     Class<?>[] getSharedParameterTypes() {
 301         return parameterTypes;
 302     }
 303 
 304     /**
 305      * {@inheritDoc}
 306      */
 307     @Override
 308     public Class<?>[] getParameterTypes() {
 309         return parameterTypes.clone();
 310     }
 311 
 312     /**
 313      * {@inheritDoc}
 314      * @since 1.8
 315      */
 316     public int getParameterCount() { return parameterTypes.length; }
 317 
 318 
 319     /**
 320      * {@inheritDoc}
 321      * @throws GenericSignatureFormatError {@inheritDoc}
 322      * @throws TypeNotPresentException {@inheritDoc}
 323      * @throws MalformedParameterizedTypeException {@inheritDoc}
 324      * @since 1.5
 325      */
 326     @Override
 327     public Type[] getGenericParameterTypes() {
 328         return super.getGenericParameterTypes();
 329     }
 330 
 331     /**
 332      * {@inheritDoc}
 333      */
 334     @Override
 335     public Class<?>[] getExceptionTypes() {
 336         return exceptionTypes.clone();
 337     }
 338 
 339     /**
 340      * {@inheritDoc}
 341      * @throws GenericSignatureFormatError {@inheritDoc}
 342      * @throws TypeNotPresentException {@inheritDoc}
 343      * @throws MalformedParameterizedTypeException {@inheritDoc}
 344      * @since 1.5
 345      */
 346     @Override
 347     public Type[] getGenericExceptionTypes() {
 348         return super.getGenericExceptionTypes();
 349     }
 350 
 351     /**
 352      * Compares this {@code Method} against the specified object.  Returns
 353      * true if the objects are the same.  Two {@code Methods} are the same if
 354      * they were declared by the same class and have the same name
 355      * and formal parameter types and return type.
 356      */
 357     public boolean equals(Object obj) {
 358         if (obj != null && obj instanceof Method) {
 359             Method other = (Method)obj;
 360             if ((getDeclaringClass() == other.getDeclaringClass())
 361                 && (getName() == other.getName())) {
 362                 if (!returnType.equals(other.getReturnType()))
 363                     return false;
 364                 return equalParamTypes(parameterTypes, other.parameterTypes);
 365             }
 366         }
 367         return false;
 368     }
 369 
 370     /**
 371      * Returns a hashcode for this {@code Method}.  The hashcode is computed
 372      * as the exclusive-or of the hashcodes for the underlying
 373      * method's declaring class name and the method's name.
 374      */
 375     public int hashCode() {
 376         return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
 377     }
 378 
 379     /**
 380      * Returns a string describing this {@code Method}.  The string is
 381      * formatted as the method access modifiers, if any, followed by
 382      * the method return type, followed by a space, followed by the
 383      * class declaring the method, followed by a period, followed by
 384      * the method name, followed by a parenthesized, comma-separated
 385      * list of the method's formal parameter types. If the method
 386      * throws checked exceptions, the parameter list is followed by a
 387      * space, followed by the word "{@code throws}" followed by a
 388      * comma-separated list of the thrown exception types.
 389      * For example:
 390      * <pre>
 391      *    public boolean java.lang.Object.equals(java.lang.Object)
 392      * </pre>
 393      *
 394      * <p>The access modifiers are placed in canonical order as
 395      * specified by "The Java Language Specification".  This is
 396      * {@code public}, {@code protected} or {@code private} first,
 397      * and then other modifiers in the following order:
 398      * {@code abstract}, {@code default}, {@code static}, {@code final},
 399      * {@code synchronized}, {@code native}, {@code strictfp}.
 400      *
 401      * @return a string describing this {@code Method}
 402      *
 403      * @jls 8.4.3 Method Modifiers
 404      * @jls 9.4   Method Declarations
 405      * @jls 9.6.1 Annotation Type Elements
 406      */
 407     public String toString() {
 408         return sharedToString(Modifier.methodModifiers(),
 409                               isDefault(),
 410                               parameterTypes,
 411                               exceptionTypes);
 412     }
 413 
 414     @Override
 415     void specificToStringHeader(StringBuilder sb) {
 416         sb.append(getReturnType().getTypeName()).append(' ');
 417         sb.append(getDeclaringClass().getTypeName()).append('.');
 418         sb.append(getName());
 419     }
 420 
 421     @Override
 422     String toShortString() {
 423         StringBuilder sb = new StringBuilder("method ");
 424         sb.append(getDeclaringClass().getTypeName()).append('.');
 425         sb.append(getName());
 426         sb.append('(');
 427         StringJoiner sj = new StringJoiner(",");
 428         for (Class<?> parameterType : getParameterTypes()) {
 429             sj.add(parameterType.getTypeName());
 430         }
 431         sb.append(sj);
 432         sb.append(')');
 433         return sb.toString();
 434     }
 435 
 436     /**
 437      * Returns a string describing this {@code Method}, including
 438      * type parameters.  The string is formatted as the method access
 439      * modifiers, if any, followed by an angle-bracketed
 440      * comma-separated list of the method's type parameters, if any,
 441      * followed by the method's generic return type, followed by a
 442      * space, followed by the class declaring the method, followed by
 443      * a period, followed by the method name, followed by a
 444      * parenthesized, comma-separated list of the method's generic
 445      * formal parameter types.
 446      *
 447      * If this method was declared to take a variable number of
 448      * arguments, instead of denoting the last parameter as
 449      * "<code><i>Type</i>[]</code>", it is denoted as
 450      * "<code><i>Type</i>...</code>".
 451      *
 452      * A space is used to separate access modifiers from one another
 453      * and from the type parameters or return type.  If there are no
 454      * type parameters, the type parameter list is elided; if the type
 455      * parameter list is present, a space separates the list from the
 456      * class name.  If the method is declared to throw exceptions, the
 457      * parameter list is followed by a space, followed by the word
 458      * "{@code throws}" followed by a comma-separated list of the generic
 459      * thrown exception types.
 460      *
 461      * <p>The access modifiers are placed in canonical order as
 462      * specified by "The Java Language Specification".  This is
 463      * {@code public}, {@code protected} or {@code private} first,
 464      * and then other modifiers in the following order:
 465      * {@code abstract}, {@code default}, {@code static}, {@code final},
 466      * {@code synchronized}, {@code native}, {@code strictfp}.
 467      *
 468      * @return a string describing this {@code Method},
 469      * include type parameters
 470      *
 471      * @since 1.5
 472      *
 473      * @jls 8.4.3 Method Modifiers
 474      * @jls 9.4   Method Declarations
 475      * @jls 9.6.1 Annotation Type Elements
 476      */
 477     @Override
 478     public String toGenericString() {
 479         return sharedToGenericString(Modifier.methodModifiers(), isDefault());
 480     }
 481 
 482     @Override
 483     void specificToGenericStringHeader(StringBuilder sb) {
 484         Type genRetType = getGenericReturnType();
 485         sb.append(genRetType.getTypeName()).append(' ');
 486         sb.append(getDeclaringClass().getTypeName()).append('.');
 487         sb.append(getName());
 488     }
 489 
 490     /**
 491      * Invokes the underlying method represented by this {@code Method}
 492      * object, on the specified object with the specified parameters.
 493      * Individual parameters are automatically unwrapped to match
 494      * primitive formal parameters, and both primitive and reference
 495      * parameters are subject to method invocation conversions as
 496      * necessary.
 497      *
 498      * <p>If the underlying method is static, then the specified {@code obj}
 499      * argument is ignored. It may be null.
 500      *
 501      * <p>If the number of formal parameters required by the underlying method is
 502      * 0, the supplied {@code args} array may be of length 0 or null.
 503      *
 504      * <p>If the underlying method is an instance method, it is invoked
 505      * using dynamic method lookup as documented in The Java Language
 506      * Specification, Second Edition, section 15.12.4.4; in particular,
 507      * overriding based on the runtime type of the target object will occur.
 508      *
 509      * <p>If the underlying method is static, the class that declared
 510      * the method is initialized if it has not already been initialized.
 511      *
 512      * <p>If the method completes normally, the value it returns is
 513      * returned to the caller of invoke; if the value has a primitive
 514      * type, it is first appropriately wrapped in an object. However,
 515      * if the value has the type of an array of a primitive type, the
 516      * elements of the array are <i>not</i> wrapped in objects; in
 517      * other words, an array of primitive type is returned.  If the
 518      * underlying method return type is void, the invocation returns
 519      * null.
 520      *
 521      * @param obj  the object the underlying method is invoked from
 522      * @param args the arguments used for the method call
 523      * @return the result of dispatching the method represented by
 524      * this object on {@code obj} with parameters
 525      * {@code args}
 526      *
 527      * @exception IllegalAccessException    if this {@code Method} object
 528      *              is enforcing Java language access control and the underlying
 529      *              method is inaccessible.
 530      * @exception IllegalArgumentException  if the method is an
 531      *              instance method and the specified object argument
 532      *              is not an instance of the class or interface
 533      *              declaring the underlying method (or of a subclass
 534      *              or implementor thereof); if the number of actual
 535      *              and formal parameters differ; if an unwrapping
 536      *              conversion for primitive arguments fails; or if,
 537      *              after possible unwrapping, a parameter value
 538      *              cannot be converted to the corresponding formal
 539      *              parameter type by a method invocation conversion.
 540      * @exception InvocationTargetException if the underlying method
 541      *              throws an exception.
 542      * @exception NullPointerException      if the specified object is null
 543      *              and the method is an instance method.
 544      * @exception ExceptionInInitializerError if the initialization
 545      * provoked by this method fails.
 546      */
 547     @CallerSensitive
 548     @ForceInline // to ensure Reflection.getCallerClass optimization
 549     @HotSpotIntrinsicCandidate
 550     public Object invoke(Object obj, Object... args)
 551         throws IllegalAccessException, IllegalArgumentException,
 552            InvocationTargetException
 553     {
 554         if (!override) {
 555             Class<?> caller = Reflection.getCallerClass();
 556             checkAccess(caller, clazz,
 557                         Modifier.isStatic(modifiers) ? null : obj.getClass(),
 558                         modifiers);
 559         }
 560         MethodAccessor ma = methodAccessor;             // read volatile
 561         if (ma == null) {
 562             ma = acquireMethodAccessor();
 563         }
 564         return ma.invoke(obj, args);
 565     }
 566 
 567     /**
 568      * Returns {@code true} if this method is a bridge
 569      * method; returns {@code false} otherwise.
 570      *
 571      * @return true if and only if this method is a bridge
 572      * method as defined by the Java Language Specification.
 573      * @since 1.5
 574      */
 575     public boolean isBridge() {
 576         return (getModifiers() & Modifier.BRIDGE) != 0;
 577     }
 578 
 579     /**
 580      * {@inheritDoc}
 581      * @since 1.5
 582      */
 583     @Override
 584     public boolean isVarArgs() {
 585         return super.isVarArgs();
 586     }
 587 
 588     /**
 589      * {@inheritDoc}
 590      * @jls 13.1 The Form of a Binary
 591      * @since 1.5
 592      */
 593     @Override
 594     public boolean isSynthetic() {
 595         return super.isSynthetic();
 596     }
 597 
 598     /**
 599      * Returns {@code true} if this method is a default
 600      * method; returns {@code false} otherwise.
 601      *
 602      * A default method is a public non-abstract instance method, that
 603      * is, a non-static method with a body, declared in an interface
 604      * type.
 605      *
 606      * @return true if and only if this method is a default
 607      * method as defined by the Java Language Specification.
 608      * @since 1.8
 609      */
 610     public boolean isDefault() {
 611         // Default methods are public non-abstract instance methods
 612         // declared in an interface.
 613         return ((getModifiers() & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) ==
 614                 Modifier.PUBLIC) && getDeclaringClass().isInterface();
 615     }
 616 
 617     // NOTE that there is no synchronization used here. It is correct
 618     // (though not efficient) to generate more than one MethodAccessor
 619     // for a given Method. However, avoiding synchronization will
 620     // probably make the implementation more scalable.
 621     private MethodAccessor acquireMethodAccessor() {
 622         // First check to see if one has been created yet, and take it
 623         // if so
 624         MethodAccessor tmp = null;
 625         if (root != null) tmp = root.getMethodAccessor();
 626         if (tmp != null) {
 627             methodAccessor = tmp;
 628         } else {
 629             // Otherwise fabricate one and propagate it up to the root
 630             tmp = reflectionFactory.newMethodAccessor(this);
 631             setMethodAccessor(tmp);
 632         }
 633 
 634         return tmp;
 635     }
 636 
 637     // Returns MethodAccessor for this Method object, not looking up
 638     // the chain to the root
 639     MethodAccessor getMethodAccessor() {
 640         return methodAccessor;
 641     }
 642 
 643     // Sets the MethodAccessor for this Method object and
 644     // (recursively) its root
 645     void setMethodAccessor(MethodAccessor accessor) {
 646         methodAccessor = accessor;
 647         // Propagate up
 648         if (root != null) {
 649             root.setMethodAccessor(accessor);
 650         }
 651     }
 652 
 653     /**
 654      * Returns the default value for the annotation member represented by
 655      * this {@code Method} instance.  If the member is of a primitive type,
 656      * an instance of the corresponding wrapper type is returned. Returns
 657      * null if no default is associated with the member, or if the method
 658      * instance does not represent a declared member of an annotation type.
 659      *
 660      * @return the default value for the annotation member represented
 661      *     by this {@code Method} instance.
 662      * @throws TypeNotPresentException if the annotation is of type
 663      *     {@link Class} and no definition can be found for the
 664      *     default class value.
 665      * @since  1.5
 666      */
 667     public Object getDefaultValue() {
 668         if  (annotationDefault == null)
 669             return null;
 670         Class<?> memberType = AnnotationType.invocationHandlerReturnType(
 671             getReturnType());
 672         Object result = AnnotationParser.parseMemberValue(
 673             memberType, ByteBuffer.wrap(annotationDefault),
 674             SharedSecrets.getJavaLangAccess().
 675                 getConstantPool(getDeclaringClass()),
 676             getDeclaringClass());
 677         if (result instanceof ExceptionProxy) {
 678             if (result instanceof TypeNotPresentExceptionProxy) {
 679                 TypeNotPresentExceptionProxy proxy = (TypeNotPresentExceptionProxy)result;
 680                 throw new TypeNotPresentException(proxy.typeName(), proxy.getCause());
 681             }
 682             throw new AnnotationFormatError("Invalid default: " + this);
 683         }
 684         return result;
 685     }
 686 
 687     /**
 688      * {@inheritDoc}
 689      * @throws NullPointerException  {@inheritDoc}
 690      * @since 1.5
 691      */
 692     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
 693         return super.getAnnotation(annotationClass);
 694     }
 695 
 696     /**
 697      * {@inheritDoc}
 698      * @since 1.5
 699      */
 700     public Annotation[] getDeclaredAnnotations()  {
 701         return super.getDeclaredAnnotations();
 702     }
 703 
 704     /**
 705      * {@inheritDoc}
 706      * @since 1.5
 707      */
 708     @Override
 709     public Annotation[][] getParameterAnnotations() {
 710         return sharedGetParameterAnnotations(parameterTypes, parameterAnnotations);
 711     }
 712 
 713     /**
 714      * {@inheritDoc}
 715      * @since 1.8
 716      */
 717     @Override
 718     public AnnotatedType getAnnotatedReturnType() {
 719         return getAnnotatedReturnType0(getGenericReturnType());
 720     }
 721 
 722     @Override
 723     boolean handleParameterNumberMismatch(int resultLength, int numParameters) {
 724         throw new AnnotationFormatError("Parameter annotations don't match number of parameters");
 725     }
 726 }