1 /*
   2  * Copyright (c) 1996, 2024, 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.access.SharedSecrets;
  29 import jdk.internal.reflect.CallerSensitive;
  30 import jdk.internal.reflect.FieldAccessor;
  31 import jdk.internal.reflect.Reflection;
  32 import jdk.internal.vm.annotation.ForceInline;
  33 import jdk.internal.vm.annotation.Stable;
  34 import sun.reflect.generics.repository.FieldRepository;
  35 import sun.reflect.generics.factory.CoreReflectionFactory;
  36 import sun.reflect.generics.factory.GenericsFactory;
  37 import sun.reflect.generics.scope.ClassScope;
  38 import java.lang.annotation.Annotation;
  39 import java.util.Map;
  40 import java.util.Set;
  41 import java.util.Objects;
  42 import sun.reflect.annotation.AnnotationParser;
  43 import sun.reflect.annotation.AnnotationSupport;
  44 import sun.reflect.annotation.TypeAnnotation;
  45 import sun.reflect.annotation.TypeAnnotationParser;
  46 
  47 /**
  48  * A {@code Field} provides information about, and dynamic access to, a
  49  * single field of a class or an interface.  The reflected field may
  50  * be a class (static) field or an instance field.
  51  *
  52  * <p>A {@code Field} permits widening conversions to occur during a get or
  53  * set access operation, but throws an {@code IllegalArgumentException} if a
  54  * narrowing conversion would occur.
  55  *
  56  * @see Member
  57  * @see java.lang.Class
  58  * @see java.lang.Class#getFields()
  59  * @see java.lang.Class#getField(String)
  60  * @see java.lang.Class#getDeclaredFields()
  61  * @see java.lang.Class#getDeclaredField(String)
  62  *
  63  * @author Kenneth Russell
  64  * @author Nakul Saraiya
  65  * @since 1.1
  66  */
  67 public final
  68 class Field extends AccessibleObject implements Member {
  69     private final Class<?>            clazz;
  70     private final int                 slot;
  71     // This is guaranteed to be interned by the VM in the 1.4
  72     // reflection implementation
  73     private final String              name;
  74     private final Class<?>            type;
  75     private final int                 modifiers;
  76     private final boolean             trustedFinal;
  77     // Generics and annotations support
  78     private final transient String    signature;
  79     private final byte[]              annotations;
  80 
  81     /**
  82      * Fields are mutable due to {@link AccessibleObject#setAccessible(boolean)}.
  83      * Thus, we return a new copy of a root each time a field is returned.
  84      * Some lazily initialized immutable states can be stored on root and shared to the copies.
  85      */
  86     private Field root;
  87     private transient volatile FieldRepository genericInfo;
  88     private @Stable FieldAccessor fieldAccessor; // access control enabled
  89     private @Stable FieldAccessor overrideFieldAccessor; // access control suppressed
  90     // End shared states
  91 
  92     // Generics infrastructure
  93 
  94     private String getGenericSignature() {return signature;}
  95 
  96     // Accessor for factory
  97     private GenericsFactory getFactory() {
  98         Class<?> c = getDeclaringClass();
  99         // create scope and factory
 100         return CoreReflectionFactory.make(c, ClassScope.make(c));
 101     }
 102 
 103     // Accessor for generic info repository
 104     private FieldRepository getGenericInfo() {
 105         var genericInfo = this.genericInfo;
 106         if (genericInfo == null) {
 107             var root = this.root;
 108             if (root != null) {
 109                 genericInfo = root.getGenericInfo();
 110             } else {
 111                 genericInfo = FieldRepository.make(getGenericSignature(), getFactory());
 112             }
 113             this.genericInfo = genericInfo;
 114         }
 115         return genericInfo;
 116     }
 117 
 118     /**
 119      * Package-private constructor
 120      */
 121     @SuppressWarnings("deprecation")
 122     Field(Class<?> declaringClass,
 123           String name,
 124           Class<?> type,
 125           int modifiers,
 126           boolean trustedFinal,
 127           int slot,
 128           String signature,
 129           byte[] annotations)
 130     {
 131         this.clazz = declaringClass;
 132         this.name = name;
 133         this.type = type;
 134         this.modifiers = modifiers;
 135         this.trustedFinal = trustedFinal;
 136         this.slot = slot;
 137         this.signature = signature;
 138         this.annotations = annotations;
 139     }
 140 
 141     /**
 142      * Package-private routine (exposed to java.lang.Class via
 143      * ReflectAccess) which returns a copy of this Field. The copy's
 144      * "root" field points to this Field.
 145      */
 146     Field copy() {
 147         // This routine enables sharing of FieldAccessor objects
 148         // among Field 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 Field");
 156 
 157         Field res = new Field(clazz, name, type, modifiers, trustedFinal, slot, signature, annotations);
 158         res.root = this;
 159         // Might as well eagerly propagate this if already present
 160         res.fieldAccessor = fieldAccessor;
 161         res.overrideFieldAccessor = overrideFieldAccessor;
 162         res.genericInfo = genericInfo;
 163 
 164         return res;
 165     }
 166 
 167     /**
 168      * @throws InaccessibleObjectException {@inheritDoc}
 169      */
 170     @Override
 171     @CallerSensitive
 172     public void setAccessible(boolean flag) {
 173         if (flag) checkCanSetAccessible(Reflection.getCallerClass());
 174         setAccessible0(flag);
 175     }
 176 
 177     @Override
 178     void checkCanSetAccessible(Class<?> caller) {
 179         checkCanSetAccessible(caller, clazz);
 180     }
 181 
 182     /**
 183      * Returns the {@code Class} object representing the class or interface
 184      * that declares the field represented by this {@code Field} object.
 185      */
 186     @Override
 187     public Class<?> getDeclaringClass() {
 188         return clazz;
 189     }
 190 
 191     /**
 192      * Returns the name of the field represented by this {@code Field} object.
 193      */
 194     public String getName() {
 195         return name;
 196     }
 197 
 198     /**
 199      * Returns the Java language modifiers for the field represented
 200      * by this {@code Field} object, as an integer. The {@code Modifier} class should
 201      * be used to decode the modifiers.
 202      *
 203      * @see Modifier
 204      * @see #accessFlags()
 205      * @jls 8.3 Field Declarations
 206      * @jls 9.3 Field (Constant) Declarations
 207      */
 208     public int getModifiers() {
 209         return modifiers;
 210     }
 211 
 212     /**
 213      * {@return an unmodifiable set of the {@linkplain AccessFlag
 214      * access flags} for this field, possibly empty}
 215      * @see #getModifiers()
 216      * @jvms 4.5 Fields
 217      * @since 20
 218      */
 219     @Override
 220     public Set<AccessFlag> accessFlags() {
 221         return AccessFlag.maskToAccessFlags(getModifiers(), AccessFlag.Location.FIELD);
 222     }
 223 
 224     /**
 225      * Returns {@code true} if this field represents an element of
 226      * an enumerated class; returns {@code false} otherwise.
 227      *
 228      * @return {@code true} if and only if this field represents an element of
 229      * an enumerated class.
 230      * @since 1.5
 231      * @jls 8.9.1 Enum Constants
 232      */
 233     public boolean isEnumConstant() {
 234         return (getModifiers() & Modifier.ENUM) != 0;
 235     }
 236 
 237     /**
 238      * Returns {@code true} if this field is a synthetic
 239      * field; returns {@code false} otherwise.
 240      *
 241      * @return true if and only if this field is a synthetic
 242      * field as defined by the Java Language Specification.
 243      * @since 1.5
 244      * @see <a
 245      * href="{@docRoot}/java.base/java/lang/reflect/package-summary.html#LanguageJvmModel">Java
 246      * programming language and JVM modeling in core reflection</a>
 247      */
 248     public boolean isSynthetic() {
 249         return Modifier.isSynthetic(getModifiers());
 250     }
 251 
 252     /**
 253      * Returns a {@code Class} object that identifies the
 254      * declared type for the field represented by this
 255      * {@code Field} object.
 256      *
 257      * @return a {@code Class} object identifying the declared
 258      * type of the field represented by this object
 259      */
 260     public Class<?> getType() {
 261         return type;
 262     }
 263 
 264     /**
 265      * Returns a {@code Type} object that represents the declared type for
 266      * the field represented by this {@code Field} object.
 267      *
 268      * <p>If the declared type of the field is a parameterized type,
 269      * the {@code Type} object returned must accurately reflect the
 270      * actual type arguments used in the source code.
 271      *
 272      * <p>If the type of the underlying field is a type variable or a
 273      * parameterized type, it is created. Otherwise, it is resolved.
 274      *
 275      * @return a {@code Type} object that represents the declared type for
 276      *     the field represented by this {@code Field} object
 277      * @throws GenericSignatureFormatError if the generic field
 278      *     signature does not conform to the format specified in
 279      *     <cite>The Java Virtual Machine Specification</cite>
 280      * @throws TypeNotPresentException if the generic type
 281      *     signature of the underlying field refers to a non-existent
 282      *     class or interface declaration
 283      * @throws MalformedParameterizedTypeException if the generic
 284      *     signature of the underlying field refers to a parameterized type
 285      *     that cannot be instantiated for any reason
 286      * @since 1.5
 287      */
 288     public Type getGenericType() {
 289         if (getGenericSignature() != null)
 290             return getGenericInfo().getGenericType();
 291         else
 292             return getType();
 293     }
 294 
 295 
 296     /**
 297      * Compares this {@code Field} against the specified object.  Returns
 298      * true if the objects are the same.  Two {@code Field} objects are the same if
 299      * they were declared by the same class and have the same name
 300      * and type.
 301      */
 302     public boolean equals(Object obj) {
 303         if (obj instanceof Field other) {
 304             return (getDeclaringClass() == other.getDeclaringClass())
 305                 && (getName() == other.getName())
 306                 && (getType() == other.getType());
 307         }
 308         return false;
 309     }
 310 
 311     /**
 312      * Returns a hashcode for this {@code Field}.  This is computed as the
 313      * exclusive-or of the hashcodes for the underlying field's
 314      * declaring class name and its name.
 315      */
 316     public int hashCode() {
 317         return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
 318     }
 319 
 320     /**
 321      * Returns a string describing this {@code Field}.  The format is
 322      * the access modifiers for the field, if any, followed
 323      * by the field type, followed by a space, followed by
 324      * the fully-qualified name of the class declaring the field,
 325      * followed by a period, followed by the name of the field.
 326      * For example:
 327      * <pre>
 328      *    public static final int java.lang.Thread.MIN_PRIORITY
 329      *    private int java.io.FileDescriptor.fd
 330      * </pre>
 331      *
 332      * <p>The modifiers are placed in canonical order as specified by
 333      * "The Java Language Specification".  This is {@code public},
 334      * {@code protected} or {@code private} first, and then other
 335      * modifiers in the following order: {@code static}, {@code final},
 336      * {@code transient}, {@code volatile}.
 337      *
 338      * @return a string describing this {@code Field}
 339      * @jls 8.3.1 Field Modifiers
 340      */
 341     public String toString() {
 342         int mod = getModifiers();
 343         return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
 344             + getType().getTypeName() + " "
 345             + getDeclaringClass().getTypeName() + "."
 346             + getName());
 347     }
 348 
 349     @Override
 350     String toShortString() {
 351         return "field " + getDeclaringClass().getTypeName() + "." + getName();
 352     }
 353 
 354     /**
 355      * Returns a string describing this {@code Field}, including
 356      * its generic type.  The format is the access modifiers for the
 357      * field, if any, followed by the generic field type, followed by
 358      * a space, followed by the fully-qualified name of the class
 359      * declaring the field, followed by a period, followed by the name
 360      * of the field.
 361      *
 362      * <p>The modifiers are placed in canonical order as specified by
 363      * "The Java Language Specification".  This is {@code public},
 364      * {@code protected} or {@code private} first, and then other
 365      * modifiers in the following order: {@code static}, {@code final},
 366      * {@code transient}, {@code volatile}.
 367      *
 368      * @return a string describing this {@code Field}, including
 369      * its generic type
 370      *
 371      * @since 1.5
 372      * @jls 8.3.1 Field Modifiers
 373      */
 374     public String toGenericString() {
 375         int mod = getModifiers();
 376         Type fieldType = getGenericType();
 377         return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
 378             + fieldType.getTypeName() + " "
 379             + getDeclaringClass().getTypeName() + "."
 380             + getName());
 381     }
 382 
 383     /**
 384      * Returns the value of the field represented by this {@code Field}, on
 385      * the specified object. The value is automatically wrapped in an
 386      * object if it has a primitive type.
 387      *
 388      * <p>The underlying field's value is obtained as follows:
 389      *
 390      * <p>If the underlying field is a static field, the {@code obj} argument
 391      * is ignored; it may be null.
 392      *
 393      * <p>Otherwise, the underlying field is an instance field.  If the
 394      * specified {@code obj} argument is null, the method throws a
 395      * {@code NullPointerException}. If the specified object is not an
 396      * instance of the class or interface declaring the underlying
 397      * field, the method throws an {@code IllegalArgumentException}.
 398      *
 399      * <p>If this {@code Field} object is enforcing Java language access control, and
 400      * the underlying field is inaccessible, the method throws an
 401      * {@code IllegalAccessException}.
 402      * If the underlying field is static, the class that declared the
 403      * field is initialized if it has not already been initialized.
 404      *
 405      * <p>Otherwise, the value is retrieved from the underlying instance
 406      * or static field.  If the field has a primitive type, the value
 407      * is wrapped in an object before being returned, otherwise it is
 408      * returned as is.
 409      *
 410      * <p>If the field is hidden in the type of {@code obj},
 411      * the field's value is obtained according to the preceding rules.
 412      *
 413      * @param obj object from which the represented field's value is
 414      * to be extracted
 415      * @return the value of the represented field in object
 416      * {@code obj}; primitive values are wrapped in an appropriate
 417      * object before being returned
 418      *
 419      * @throws    IllegalAccessException    if this {@code Field} object
 420      *              is enforcing Java language access control and the underlying
 421      *              field is inaccessible.
 422      * @throws    IllegalArgumentException  if the specified object is not an
 423      *              instance of the class or interface declaring the underlying
 424      *              field (or a subclass or implementor thereof).
 425      * @throws    NullPointerException      if the specified object is null
 426      *              and the field is an instance field.
 427      * @throws    ExceptionInInitializerError if the initialization provoked
 428      *              by this method fails.
 429      */
 430     @CallerSensitive
 431     @ForceInline // to ensure Reflection.getCallerClass optimization
 432     public Object get(Object obj)
 433         throws IllegalArgumentException, IllegalAccessException
 434     {
 435         if (!override) {
 436             Class<?> caller = Reflection.getCallerClass();
 437             checkAccess(caller, obj);
 438             return getFieldAccessor().get(obj);
 439         } else {
 440             return getOverrideFieldAccessor().get(obj);
 441         }
 442     }
 443 
 444     /**
 445      * Gets the value of a static or instance {@code boolean} field.
 446      *
 447      * @param obj the object to extract the {@code boolean} value
 448      * from
 449      * @return the value of the {@code boolean} field
 450      *
 451      * @throws    IllegalAccessException    if this {@code Field} object
 452      *              is enforcing Java language access control and the underlying
 453      *              field is inaccessible.
 454      * @throws    IllegalArgumentException  if the specified object is not
 455      *              an instance of the class or interface declaring the
 456      *              underlying field (or a subclass or implementor
 457      *              thereof), or if the field value cannot be
 458      *              converted to the type {@code boolean} by a
 459      *              widening conversion.
 460      * @throws    NullPointerException      if the specified object is null
 461      *              and the field is an instance field.
 462      * @throws    ExceptionInInitializerError if the initialization provoked
 463      *              by this method fails.
 464      * @see       Field#get
 465      */
 466     @CallerSensitive
 467     @ForceInline // to ensure Reflection.getCallerClass optimization
 468     public boolean getBoolean(Object obj)
 469         throws IllegalArgumentException, IllegalAccessException
 470     {
 471         if (!override) {
 472             Class<?> caller = Reflection.getCallerClass();
 473             checkAccess(caller, obj);
 474             return getFieldAccessor().getBoolean(obj);
 475         } else {
 476             return getOverrideFieldAccessor().getBoolean(obj);
 477         }
 478     }
 479 
 480     /**
 481      * Gets the value of a static or instance {@code byte} field.
 482      *
 483      * @param obj the object to extract the {@code byte} value
 484      * from
 485      * @return the value of the {@code byte} field
 486      *
 487      * @throws    IllegalAccessException    if this {@code Field} object
 488      *              is enforcing Java language access control and the underlying
 489      *              field is inaccessible.
 490      * @throws    IllegalArgumentException  if the specified object is not
 491      *              an instance of the class or interface declaring the
 492      *              underlying field (or a subclass or implementor
 493      *              thereof), or if the field value cannot be
 494      *              converted to the type {@code byte} by a
 495      *              widening conversion.
 496      * @throws    NullPointerException      if the specified object is null
 497      *              and the field is an instance field.
 498      * @throws    ExceptionInInitializerError if the initialization provoked
 499      *              by this method fails.
 500      * @see       Field#get
 501      */
 502     @CallerSensitive
 503     @ForceInline // to ensure Reflection.getCallerClass optimization
 504     public byte getByte(Object obj)
 505         throws IllegalArgumentException, IllegalAccessException
 506     {
 507         if (!override) {
 508             Class<?> caller = Reflection.getCallerClass();
 509             checkAccess(caller, obj);
 510             return getFieldAccessor().getByte(obj);
 511         } else {
 512             return getOverrideFieldAccessor().getByte(obj);
 513         }
 514     }
 515 
 516     /**
 517      * Gets the value of a static or instance field of type
 518      * {@code char} or of another primitive type convertible to
 519      * type {@code char} via a widening conversion.
 520      *
 521      * @param obj the object to extract the {@code char} value
 522      * from
 523      * @return the value of the field converted to type {@code char}
 524      *
 525      * @throws    IllegalAccessException    if this {@code Field} object
 526      *              is enforcing Java language access control and the underlying
 527      *              field is inaccessible.
 528      * @throws    IllegalArgumentException  if the specified object is not
 529      *              an instance of the class or interface declaring the
 530      *              underlying field (or a subclass or implementor
 531      *              thereof), or if the field value cannot be
 532      *              converted to the type {@code char} by a
 533      *              widening conversion.
 534      * @throws    NullPointerException      if the specified object is null
 535      *              and the field is an instance field.
 536      * @throws    ExceptionInInitializerError if the initialization provoked
 537      *              by this method fails.
 538      * @see Field#get
 539      */
 540     @CallerSensitive
 541     @ForceInline // to ensure Reflection.getCallerClass optimization
 542     public char getChar(Object obj)
 543         throws IllegalArgumentException, IllegalAccessException
 544     {
 545         if (!override) {
 546             Class<?> caller = Reflection.getCallerClass();
 547             checkAccess(caller, obj);
 548             return getFieldAccessor().getChar(obj);
 549         } else {
 550             return getOverrideFieldAccessor().getChar(obj);
 551         }
 552     }
 553 
 554     /**
 555      * Gets the value of a static or instance field of type
 556      * {@code short} or of another primitive type convertible to
 557      * type {@code short} via a widening conversion.
 558      *
 559      * @param obj the object to extract the {@code short} value
 560      * from
 561      * @return the value of the field converted to type {@code short}
 562      *
 563      * @throws    IllegalAccessException    if this {@code Field} object
 564      *              is enforcing Java language access control and the underlying
 565      *              field is inaccessible.
 566      * @throws    IllegalArgumentException  if the specified object is not
 567      *              an instance of the class or interface declaring the
 568      *              underlying field (or a subclass or implementor
 569      *              thereof), or if the field value cannot be
 570      *              converted to the type {@code short} by a
 571      *              widening conversion.
 572      * @throws    NullPointerException      if the specified object is null
 573      *              and the field is an instance field.
 574      * @throws    ExceptionInInitializerError if the initialization provoked
 575      *              by this method fails.
 576      * @see       Field#get
 577      */
 578     @CallerSensitive
 579     @ForceInline // to ensure Reflection.getCallerClass optimization
 580     public short getShort(Object obj)
 581         throws IllegalArgumentException, IllegalAccessException
 582     {
 583         if (!override) {
 584             Class<?> caller = Reflection.getCallerClass();
 585             checkAccess(caller, obj);
 586             return getFieldAccessor().getShort(obj);
 587         } else {
 588             return getOverrideFieldAccessor().getShort(obj);
 589         }
 590     }
 591 
 592     /**
 593      * Gets the value of a static or instance field of type
 594      * {@code int} or of another primitive type convertible to
 595      * type {@code int} via a widening conversion.
 596      *
 597      * @param obj the object to extract the {@code int} value
 598      * from
 599      * @return the value of the field converted to type {@code int}
 600      *
 601      * @throws    IllegalAccessException    if this {@code Field} object
 602      *              is enforcing Java language access control and the underlying
 603      *              field is inaccessible.
 604      * @throws    IllegalArgumentException  if the specified object is not
 605      *              an instance of the class or interface declaring the
 606      *              underlying field (or a subclass or implementor
 607      *              thereof), or if the field value cannot be
 608      *              converted to the type {@code int} by a
 609      *              widening conversion.
 610      * @throws    NullPointerException      if the specified object is null
 611      *              and the field is an instance field.
 612      * @throws    ExceptionInInitializerError if the initialization provoked
 613      *              by this method fails.
 614      * @see       Field#get
 615      */
 616     @CallerSensitive
 617     @ForceInline // to ensure Reflection.getCallerClass optimization
 618     public int getInt(Object obj)
 619         throws IllegalArgumentException, IllegalAccessException
 620     {
 621         if (!override) {
 622             Class<?> caller = Reflection.getCallerClass();
 623             checkAccess(caller, obj);
 624             return getFieldAccessor().getInt(obj);
 625         } else {
 626             return getOverrideFieldAccessor().getInt(obj);
 627         }
 628     }
 629 
 630     /**
 631      * Gets the value of a static or instance field of type
 632      * {@code long} or of another primitive type convertible to
 633      * type {@code long} via a widening conversion.
 634      *
 635      * @param obj the object to extract the {@code long} value
 636      * from
 637      * @return the value of the field converted to type {@code long}
 638      *
 639      * @throws    IllegalAccessException    if this {@code Field} object
 640      *              is enforcing Java language access control and the underlying
 641      *              field is inaccessible.
 642      * @throws    IllegalArgumentException  if the specified object is not
 643      *              an instance of the class or interface declaring the
 644      *              underlying field (or a subclass or implementor
 645      *              thereof), or if the field value cannot be
 646      *              converted to the type {@code long} by a
 647      *              widening conversion.
 648      * @throws    NullPointerException      if the specified object is null
 649      *              and the field is an instance field.
 650      * @throws    ExceptionInInitializerError if the initialization provoked
 651      *              by this method fails.
 652      * @see       Field#get
 653      */
 654     @CallerSensitive
 655     @ForceInline // to ensure Reflection.getCallerClass optimization
 656     public long getLong(Object obj)
 657         throws IllegalArgumentException, IllegalAccessException
 658     {
 659         if (!override) {
 660             Class<?> caller = Reflection.getCallerClass();
 661             checkAccess(caller, obj);
 662             return getFieldAccessor().getLong(obj);
 663         } else {
 664             return getOverrideFieldAccessor().getLong(obj);
 665         }
 666     }
 667 
 668     /**
 669      * Gets the value of a static or instance field of type
 670      * {@code float} or of another primitive type convertible to
 671      * type {@code float} via a widening conversion.
 672      *
 673      * @param obj the object to extract the {@code float} value
 674      * from
 675      * @return the value of the field converted to type {@code float}
 676      *
 677      * @throws    IllegalAccessException    if this {@code Field} object
 678      *              is enforcing Java language access control and the underlying
 679      *              field is inaccessible.
 680      * @throws    IllegalArgumentException  if the specified object is not
 681      *              an instance of the class or interface declaring the
 682      *              underlying field (or a subclass or implementor
 683      *              thereof), or if the field value cannot be
 684      *              converted to the type {@code float} by a
 685      *              widening conversion.
 686      * @throws    NullPointerException      if the specified object is null
 687      *              and the field is an instance field.
 688      * @throws    ExceptionInInitializerError if the initialization provoked
 689      *              by this method fails.
 690      * @see Field#get
 691      */
 692     @CallerSensitive
 693     @ForceInline // to ensure Reflection.getCallerClass optimization
 694     public float getFloat(Object obj)
 695         throws IllegalArgumentException, IllegalAccessException
 696     {
 697         if (!override) {
 698             Class<?> caller = Reflection.getCallerClass();
 699             checkAccess(caller, obj);
 700             return getFieldAccessor().getFloat(obj);
 701         } else {
 702             return getOverrideFieldAccessor().getFloat(obj);
 703         }
 704     }
 705 
 706     /**
 707      * Gets the value of a static or instance field of type
 708      * {@code double} or of another primitive type convertible to
 709      * type {@code double} via a widening conversion.
 710      *
 711      * @param obj the object to extract the {@code double} value
 712      * from
 713      * @return the value of the field converted to type {@code double}
 714      *
 715      * @throws    IllegalAccessException    if this {@code Field} object
 716      *              is enforcing Java language access control and the underlying
 717      *              field is inaccessible.
 718      * @throws    IllegalArgumentException  if the specified object is not
 719      *              an instance of the class or interface declaring the
 720      *              underlying field (or a subclass or implementor
 721      *              thereof), or if the field value cannot be
 722      *              converted to the type {@code double} by a
 723      *              widening conversion.
 724      * @throws    NullPointerException      if the specified object is null
 725      *              and the field is an instance field.
 726      * @throws    ExceptionInInitializerError if the initialization provoked
 727      *              by this method fails.
 728      * @see       Field#get
 729      */
 730     @CallerSensitive
 731     @ForceInline // to ensure Reflection.getCallerClass optimization
 732     public double getDouble(Object obj)
 733         throws IllegalArgumentException, IllegalAccessException
 734     {
 735         if (!override) {
 736             Class<?> caller = Reflection.getCallerClass();
 737             checkAccess(caller, obj);
 738             return getFieldAccessor().getDouble(obj);
 739         } else {
 740             return getOverrideFieldAccessor().getDouble(obj);
 741         }
 742     }
 743 
 744     /**
 745      * Sets the field represented by this {@code Field} object on the
 746      * specified object argument to the specified new value. The new
 747      * value is automatically unwrapped if the underlying field has a
 748      * primitive type.
 749      *
 750      * <p>The operation proceeds as follows:
 751      *
 752      * <p>If the underlying field is static, the {@code obj} argument is
 753      * ignored; it may be null.
 754      *
 755      * <p>Otherwise the underlying field is an instance field.  If the
 756      * specified object argument is null, the method throws a
 757      * {@code NullPointerException}.  If the specified object argument is not
 758      * an instance of the class or interface declaring the underlying
 759      * field, the method throws an {@code IllegalArgumentException}.
 760      *
 761      * <p>If this {@code Field} object is enforcing Java language access control, and
 762      * the underlying field is inaccessible, the method throws an
 763      * {@code IllegalAccessException}.
 764      *
 765      * <p>If the underlying field is final, this {@code Field} object has
 766      * <em>write</em> access if and only if the following conditions are met:
 767      * <ul>
 768      * <li>{@link #setAccessible(boolean) setAccessible(true)} has succeeded for
 769      *     this {@code Field} object;</li>
 770      * <li>the field is non-static; and</li>
 771      * <li>the field's declaring class is not a {@linkplain Class#isHidden()
 772      *     hidden class}; and</li>
 773      * <li>the field's declaring class is not a {@linkplain Class#isRecord()
 774      *     record class}.</li>
 775      * </ul>
 776      * If any of the above checks is not met, this method throws an
 777      * {@code IllegalAccessException}.
 778      *
 779      * <p> Setting a final field in this way
 780      * is meaningful only during deserialization or reconstruction of
 781      * instances of classes with blank final fields, before they are
 782      * made available for access by other parts of a program. Use in
 783      * any other context may have unpredictable effects, including cases
 784      * in which other parts of a program continue to use the original
 785      * value of this field.
 786      *
 787      * <p>If the underlying field is of a primitive type, an unwrapping
 788      * conversion is attempted to convert the new value to a value of
 789      * a primitive type.  If this attempt fails, the method throws an
 790      * {@code IllegalArgumentException}.
 791      *
 792      * <p>If, after possible unwrapping, the new value cannot be
 793      * converted to the type of the underlying field by an identity or
 794      * widening conversion, the method throws an
 795      * {@code IllegalArgumentException}.
 796      *
 797      * <p>If the underlying field is static, the class that declared the
 798      * field is initialized if it has not already been initialized.
 799      *
 800      * <p>The field is set to the possibly unwrapped and widened new value.
 801      *
 802      * <p>If the field is hidden in the type of {@code obj},
 803      * the field's value is set according to the preceding rules.
 804      *
 805      * @param obj the object whose field should be modified
 806      * @param value the new value for the field of {@code obj}
 807      * being modified
 808      *
 809      * @throws    IllegalAccessException    if this {@code Field} object
 810      *              is enforcing Java language access control and the underlying
 811      *              field is inaccessible or final;
 812      *              or if this {@code Field} object has no write access.
 813      * @throws    IllegalArgumentException  if the specified object is not an
 814      *              instance of the class or interface declaring the underlying
 815      *              field (or a subclass or implementor thereof),
 816      *              or if an unwrapping conversion fails.
 817      * @throws    NullPointerException      if the specified object is null
 818      *              and the field is an instance field.
 819      * @throws    ExceptionInInitializerError if the initialization provoked
 820      *              by this method fails.
 821      */
 822     @CallerSensitive
 823     @ForceInline // to ensure Reflection.getCallerClass optimization
 824     public void set(Object obj, Object value)
 825         throws IllegalArgumentException, IllegalAccessException
 826     {
 827         if (!override) {
 828             Class<?> caller = Reflection.getCallerClass();
 829             checkAccess(caller, obj);
 830             getFieldAccessor().set(obj, value);
 831         } else {
 832             getOverrideFieldAccessor().set(obj, value);
 833         }
 834     }
 835 
 836     /**
 837      * Sets the value of a field as a {@code boolean} on the specified object.
 838      * This method is equivalent to
 839      * {@code set(obj, zObj)},
 840      * where {@code zObj} is a {@code Boolean} object and
 841      * {@code zObj.booleanValue() == z}.
 842      *
 843      * @param obj the object whose field should be modified
 844      * @param z   the new value for the field of {@code obj}
 845      * being modified
 846      *
 847      * @throws    IllegalAccessException    if this {@code Field} object
 848      *              is enforcing Java language access control and the underlying
 849      *              field is either inaccessible or final;
 850      *              or if this {@code Field} object has no write access.
 851      * @throws    IllegalArgumentException  if the specified object is not an
 852      *              instance of the class or interface declaring the underlying
 853      *              field (or a subclass or implementor thereof),
 854      *              or if an unwrapping conversion fails.
 855      * @throws    NullPointerException      if the specified object is null
 856      *              and the field is an instance field.
 857      * @throws    ExceptionInInitializerError if the initialization provoked
 858      *              by this method fails.
 859      * @see       Field#set
 860      */
 861     @CallerSensitive
 862     @ForceInline // to ensure Reflection.getCallerClass optimization
 863     public void setBoolean(Object obj, boolean z)
 864         throws IllegalArgumentException, IllegalAccessException
 865     {
 866         if (!override) {
 867             Class<?> caller = Reflection.getCallerClass();
 868             checkAccess(caller, obj);
 869             getFieldAccessor().setBoolean(obj, z);
 870         } else {
 871             getOverrideFieldAccessor().setBoolean(obj, z);
 872         }
 873     }
 874 
 875     /**
 876      * Sets the value of a field as a {@code byte} on the specified object.
 877      * This method is equivalent to
 878      * {@code set(obj, bObj)},
 879      * where {@code bObj} is a {@code Byte} object and
 880      * {@code bObj.byteValue() == b}.
 881      *
 882      * @param obj the object whose field should be modified
 883      * @param b   the new value for the field of {@code obj}
 884      * being modified
 885      *
 886      * @throws    IllegalAccessException    if this {@code Field} object
 887      *              is enforcing Java language access control and the underlying
 888      *              field is either inaccessible or final;
 889      *              or if this {@code Field} object has no write access.
 890      * @throws    IllegalArgumentException  if the specified object is not an
 891      *              instance of the class or interface declaring the underlying
 892      *              field (or a subclass or implementor thereof),
 893      *              or if an unwrapping conversion fails.
 894      * @throws    NullPointerException      if the specified object is null
 895      *              and the field is an instance field.
 896      * @throws    ExceptionInInitializerError if the initialization provoked
 897      *              by this method fails.
 898      * @see       Field#set
 899      */
 900     @CallerSensitive
 901     @ForceInline // to ensure Reflection.getCallerClass optimization
 902     public void setByte(Object obj, byte b)
 903         throws IllegalArgumentException, IllegalAccessException
 904     {
 905         if (!override) {
 906             Class<?> caller = Reflection.getCallerClass();
 907             checkAccess(caller, obj);
 908             getFieldAccessor().setByte(obj, b);
 909         } else {
 910             getOverrideFieldAccessor().setByte(obj, b);
 911         }
 912     }
 913 
 914     /**
 915      * Sets the value of a field as a {@code char} on the specified object.
 916      * This method is equivalent to
 917      * {@code set(obj, cObj)},
 918      * where {@code cObj} is a {@code Character} object and
 919      * {@code cObj.charValue() == c}.
 920      *
 921      * @param obj the object whose field should be modified
 922      * @param c   the new value for the field of {@code obj}
 923      * being modified
 924      *
 925      * @throws    IllegalAccessException    if this {@code Field} object
 926      *              is enforcing Java language access control and the underlying
 927      *              field is either inaccessible or final;
 928      *              or if this {@code Field} object has no write access.
 929      * @throws    IllegalArgumentException  if the specified object is not an
 930      *              instance of the class or interface declaring the underlying
 931      *              field (or a subclass or implementor thereof),
 932      *              or if an unwrapping conversion fails.
 933      * @throws    NullPointerException      if the specified object is null
 934      *              and the field is an instance field.
 935      * @throws    ExceptionInInitializerError if the initialization provoked
 936      *              by this method fails.
 937      * @see       Field#set
 938      */
 939     @CallerSensitive
 940     @ForceInline // to ensure Reflection.getCallerClass optimization
 941     public void setChar(Object obj, char c)
 942         throws IllegalArgumentException, IllegalAccessException
 943     {
 944         if (!override) {
 945             Class<?> caller = Reflection.getCallerClass();
 946             checkAccess(caller, obj);
 947             getFieldAccessor().setChar(obj, c);
 948         } else {
 949             getOverrideFieldAccessor().setChar(obj, c);
 950         }
 951     }
 952 
 953     /**
 954      * Sets the value of a field as a {@code short} on the specified object.
 955      * This method is equivalent to
 956      * {@code set(obj, sObj)},
 957      * where {@code sObj} is a {@code Short} object and
 958      * {@code sObj.shortValue() == s}.
 959      *
 960      * @param obj the object whose field should be modified
 961      * @param s   the new value for the field of {@code obj}
 962      * being modified
 963      *
 964      * @throws    IllegalAccessException    if this {@code Field} object
 965      *              is enforcing Java language access control and the underlying
 966      *              field is either inaccessible or final;
 967      *              or if this {@code Field} object has no write access.
 968      * @throws    IllegalArgumentException  if the specified object is not an
 969      *              instance of the class or interface declaring the underlying
 970      *              field (or a subclass or implementor thereof),
 971      *              or if an unwrapping conversion fails.
 972      * @throws    NullPointerException      if the specified object is null
 973      *              and the field is an instance field.
 974      * @throws    ExceptionInInitializerError if the initialization provoked
 975      *              by this method fails.
 976      * @see       Field#set
 977      */
 978     @CallerSensitive
 979     @ForceInline // to ensure Reflection.getCallerClass optimization
 980     public void setShort(Object obj, short s)
 981         throws IllegalArgumentException, IllegalAccessException
 982     {
 983         if (!override) {
 984             Class<?> caller = Reflection.getCallerClass();
 985             checkAccess(caller, obj);
 986             getFieldAccessor().setShort(obj, s);
 987         } else {
 988             getOverrideFieldAccessor().setShort(obj, s);
 989         }
 990     }
 991 
 992     /**
 993      * Sets the value of a field as an {@code int} on the specified object.
 994      * This method is equivalent to
 995      * {@code set(obj, iObj)},
 996      * where {@code iObj} is an {@code Integer} object and
 997      * {@code iObj.intValue() == i}.
 998      *
 999      * @param obj the object whose field should be modified
1000      * @param i   the new value for the field of {@code obj}
1001      * being modified
1002      *
1003      * @throws    IllegalAccessException    if this {@code Field} object
1004      *              is enforcing Java language access control and the underlying
1005      *              field is either inaccessible or final;
1006      *              or if this {@code Field} object has no write access.
1007      * @throws    IllegalArgumentException  if the specified object is not an
1008      *              instance of the class or interface declaring the underlying
1009      *              field (or a subclass or implementor thereof),
1010      *              or if an unwrapping conversion fails.
1011      * @throws    NullPointerException      if the specified object is null
1012      *              and the field is an instance field.
1013      * @throws    ExceptionInInitializerError if the initialization provoked
1014      *              by this method fails.
1015      * @see       Field#set
1016      */
1017     @CallerSensitive
1018     @ForceInline // to ensure Reflection.getCallerClass optimization
1019     public void setInt(Object obj, int i)
1020         throws IllegalArgumentException, IllegalAccessException
1021     {
1022         if (!override) {
1023             Class<?> caller = Reflection.getCallerClass();
1024             checkAccess(caller, obj);
1025             getFieldAccessor().setInt(obj, i);
1026         } else {
1027             getOverrideFieldAccessor().setInt(obj, i);
1028         }
1029     }
1030 
1031     /**
1032      * Sets the value of a field as a {@code long} on the specified object.
1033      * This method is equivalent to
1034      * {@code set(obj, lObj)},
1035      * where {@code lObj} is a {@code Long} object and
1036      * {@code lObj.longValue() == l}.
1037      *
1038      * @param obj the object whose field should be modified
1039      * @param l   the new value for the field of {@code obj}
1040      * being modified
1041      *
1042      * @throws    IllegalAccessException    if this {@code Field} object
1043      *              is enforcing Java language access control and the underlying
1044      *              field is either inaccessible or final;
1045      *              or if this {@code Field} object has no write access.
1046      * @throws    IllegalArgumentException  if the specified object is not an
1047      *              instance of the class or interface declaring the underlying
1048      *              field (or a subclass or implementor thereof),
1049      *              or if an unwrapping conversion fails.
1050      * @throws    NullPointerException      if the specified object is null
1051      *              and the field is an instance field.
1052      * @throws    ExceptionInInitializerError if the initialization provoked
1053      *              by this method fails.
1054      * @see       Field#set
1055      */
1056     @CallerSensitive
1057     @ForceInline // to ensure Reflection.getCallerClass optimization
1058     public void setLong(Object obj, long l)
1059         throws IllegalArgumentException, IllegalAccessException
1060     {
1061         if (!override) {
1062             Class<?> caller = Reflection.getCallerClass();
1063             checkAccess(caller, obj);
1064             getFieldAccessor().setLong(obj, l);
1065         } else {
1066             getOverrideFieldAccessor().setLong(obj, l);
1067         }
1068     }
1069 
1070     /**
1071      * Sets the value of a field as a {@code float} on the specified object.
1072      * This method is equivalent to
1073      * {@code set(obj, fObj)},
1074      * where {@code fObj} is a {@code Float} object and
1075      * {@code fObj.floatValue() == f}.
1076      *
1077      * @param obj the object whose field should be modified
1078      * @param f   the new value for the field of {@code obj}
1079      * being modified
1080      *
1081      * @throws    IllegalAccessException    if this {@code Field} object
1082      *              is enforcing Java language access control and the underlying
1083      *              field is either inaccessible or final;
1084      *              or if this {@code Field} object has no write access.
1085      * @throws    IllegalArgumentException  if the specified object is not an
1086      *              instance of the class or interface declaring the underlying
1087      *              field (or a subclass or implementor thereof),
1088      *              or if an unwrapping conversion fails.
1089      * @throws    NullPointerException      if the specified object is null
1090      *              and the field is an instance field.
1091      * @throws    ExceptionInInitializerError if the initialization provoked
1092      *              by this method fails.
1093      * @see       Field#set
1094      */
1095     @CallerSensitive
1096     @ForceInline // to ensure Reflection.getCallerClass optimization
1097     public void setFloat(Object obj, float f)
1098         throws IllegalArgumentException, IllegalAccessException
1099     {
1100         if (!override) {
1101             Class<?> caller = Reflection.getCallerClass();
1102             checkAccess(caller, obj);
1103             getFieldAccessor().setFloat(obj, f);
1104         } else {
1105             getOverrideFieldAccessor().setFloat(obj, f);
1106         }
1107     }
1108 
1109     /**
1110      * Sets the value of a field as a {@code double} on the specified object.
1111      * This method is equivalent to
1112      * {@code set(obj, dObj)},
1113      * where {@code dObj} is a {@code Double} object and
1114      * {@code dObj.doubleValue() == d}.
1115      *
1116      * @param obj the object whose field should be modified
1117      * @param d   the new value for the field of {@code obj}
1118      * being modified
1119      *
1120      * @throws    IllegalAccessException    if this {@code Field} object
1121      *              is enforcing Java language access control and the underlying
1122      *              field is either inaccessible or final;
1123      *              or if this {@code Field} object has no write access.
1124      * @throws    IllegalArgumentException  if the specified object is not an
1125      *              instance of the class or interface declaring the underlying
1126      *              field (or a subclass or implementor thereof),
1127      *              or if an unwrapping conversion fails.
1128      * @throws    NullPointerException      if the specified object is null
1129      *              and the field is an instance field.
1130      * @throws    ExceptionInInitializerError if the initialization provoked
1131      *              by this method fails.
1132      * @see       Field#set
1133      */
1134     @CallerSensitive
1135     @ForceInline // to ensure Reflection.getCallerClass optimization
1136     public void setDouble(Object obj, double d)
1137         throws IllegalArgumentException, IllegalAccessException
1138     {
1139         if (!override) {
1140             Class<?> caller = Reflection.getCallerClass();
1141             checkAccess(caller, obj);
1142             getFieldAccessor().setDouble(obj, d);
1143         } else {
1144             getOverrideFieldAccessor().setDouble(obj, d);
1145         }
1146     }
1147 
1148     // check access to field
1149     private void checkAccess(Class<?> caller, Object obj)
1150         throws IllegalAccessException
1151     {
1152         checkAccess(caller, clazz,
1153                     Modifier.isStatic(modifiers) ? null : obj.getClass(),
1154                     modifiers);
1155     }
1156 
1157     private FieldAccessor getFieldAccessor() {
1158         FieldAccessor a = fieldAccessor;
1159         return (a != null) ? a : acquireFieldAccessor();
1160     }
1161 
1162     private FieldAccessor getOverrideFieldAccessor() {
1163         FieldAccessor a = overrideFieldAccessor;
1164         return (a != null) ? a : acquireOverrideFieldAccessor();
1165     }
1166 
1167     // NOTE that there is no synchronization used here. It is correct
1168     // (though not efficient) to generate more than one FieldAccessor
1169     // for a given Field. However, avoiding synchronization will
1170     // probably make the implementation more scalable.
1171     private FieldAccessor acquireFieldAccessor() {
1172         // First check to see if one has been created yet, and take it
1173         // if so
1174         Field root = this.root;
1175         FieldAccessor tmp = root == null ? null : root.fieldAccessor;
1176         if (tmp != null) {
1177             fieldAccessor = tmp;
1178         } else {
1179             // Otherwise fabricate one and propagate it up to the root
1180             tmp = reflectionFactory.newFieldAccessor(this, false);
1181             setFieldAccessor(tmp);
1182         }
1183         return tmp;
1184     }
1185 
1186     private FieldAccessor acquireOverrideFieldAccessor() {
1187         // First check to see if one has been created yet, and take it
1188         // if so
1189         Field root = this.root;
1190         FieldAccessor tmp = root == null ? null : root.overrideFieldAccessor;
1191         if (tmp != null) {
1192             overrideFieldAccessor = tmp;
1193         } else {
1194             // Otherwise fabricate one and propagate it up to the root
1195             tmp = reflectionFactory.newFieldAccessor(this, true);
1196             setOverrideFieldAccessor(tmp);
1197         }
1198         return tmp;
1199     }
1200 
1201     // Sets the fieldAccessor for this Field object and
1202     // (recursively) its root
1203     private void setFieldAccessor(FieldAccessor accessor) {
1204         fieldAccessor = accessor;
1205         // Propagate up
1206         Field root = this.root;
1207         if (root != null) {
1208             root.setFieldAccessor(accessor);
1209         }
1210     }
1211 
1212     // Sets the overrideFieldAccessor for this Field object and
1213     // (recursively) its root
1214     private void setOverrideFieldAccessor(FieldAccessor accessor) {
1215         overrideFieldAccessor = accessor;
1216         // Propagate up
1217         Field root = this.root;
1218         if (root != null) {
1219             root.setOverrideFieldAccessor(accessor);
1220         }
1221     }
1222 
1223     @Override
1224     /* package-private */ Field getRoot() {
1225         return root;
1226     }
1227 
1228     /* package-private */ boolean isTrustedFinal() {
1229         return trustedFinal;
1230     }
1231 
1232     /**
1233      * {@inheritDoc}
1234      *
1235      * @throws NullPointerException {@inheritDoc}
1236      * @since 1.5
1237      */
1238     @Override
1239     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
1240         Objects.requireNonNull(annotationClass);
1241         return annotationClass.cast(declaredAnnotations().get(annotationClass));
1242     }
1243 
1244     /**
1245      * {@inheritDoc}
1246      *
1247      * @throws NullPointerException {@inheritDoc}
1248      * @since 1.8
1249      */
1250     @Override
1251     public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
1252         Objects.requireNonNull(annotationClass);
1253 
1254         return AnnotationSupport.getDirectlyAndIndirectlyPresent(declaredAnnotations(), annotationClass);
1255     }
1256 
1257     /**
1258      * {@inheritDoc}
1259      */
1260     @Override
1261     public Annotation[] getDeclaredAnnotations()  {
1262         return AnnotationParser.toArray(declaredAnnotations());
1263     }
1264 
1265     private transient volatile Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
1266 
1267     private Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
1268         Map<Class<? extends Annotation>, Annotation> declAnnos;
1269         if ((declAnnos = declaredAnnotations) == null) {
1270             synchronized (this) {
1271                 if ((declAnnos = declaredAnnotations) == null) {
1272                     Field root = this.root;
1273                     if (root != null) {
1274                         declAnnos = root.declaredAnnotations();
1275                     } else {
1276                         declAnnos = AnnotationParser.parseAnnotations(
1277                                 annotations,
1278                                 SharedSecrets.getJavaLangAccess()
1279                                         .getConstantPool(getDeclaringClass()),
1280                                 getDeclaringClass());
1281                     }
1282                     declaredAnnotations = declAnnos;
1283                 }
1284             }
1285         }
1286         return declAnnos;
1287     }
1288 
1289     private native byte[] getTypeAnnotationBytes0();
1290 
1291     /**
1292      * Returns an AnnotatedType object that represents the use of a type to specify
1293      * the declared type of the field represented by this Field.
1294      * @return an object representing the declared type of the field
1295      * represented by this Field
1296      *
1297      * @since 1.8
1298      */
1299     public AnnotatedType getAnnotatedType() {
1300         return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
1301                                                        SharedSecrets.getJavaLangAccess().
1302                                                            getConstantPool(getDeclaringClass()),
1303                                                        this,
1304                                                        getDeclaringClass(),
1305                                                        getGenericType(),
1306                                                        TypeAnnotation.TypeAnnotationTarget.FIELD);
1307 }
1308 }