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