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