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.invoke;
27
28 import sun.invoke.util.VerifyAccess;
29
30 import java.lang.reflect.Constructor;
31 import java.lang.reflect.Field;
32 import java.lang.reflect.Member;
33 import java.lang.reflect.Method;
34 import java.lang.reflect.Modifier;
35 import java.util.Objects;
36
37 import static java.lang.invoke.MethodHandleNatives.Constants.*;
38 import static java.lang.invoke.MethodHandleStatics.newIllegalArgumentException;
39 import static java.lang.invoke.MethodHandleStatics.newInternalError;
40
41 /**
42 * A {@code MemberName} is a compact symbolic datum which fully characterizes
43 * a method or field reference.
44 * A member name refers to a field, method, constructor, or member type.
45 * Every member name has a simple name (a string) and a type (either a Class or MethodType).
46 * A member name may also have a non-null declaring class, or it may be simply
47 * a naked name/type pair.
79 private int flags; // modifier bits; see reflect.Modifier
80 private ResolvedMethodName method; // cached resolved method information
81 //@Injected intptr_t vmindex; // vtable index or offset of resolved member
82 Object resolution; // if null, this guy is resolved
83
84 /** Return the declaring class of this member.
85 * In the case of a bare name and type, the declaring class will be null.
86 */
87 public Class<?> getDeclaringClass() {
88 return clazz;
89 }
90
91 /** Utility method producing the class loader of the declaring class. */
92 public ClassLoader getClassLoader() {
93 return clazz.getClassLoader();
94 }
95
96 /** Return the simple name of this member.
97 * For a type, it is the same as {@link Class#getSimpleName}.
98 * For a method or field, it is the simple name of the member.
99 * For a constructor, it is always {@code "<init>"}.
100 */
101 public String getName() {
102 if (name == null) {
103 expandFromVM();
104 if (name == null) {
105 return null;
106 }
107 }
108 return name;
109 }
110
111 public MethodType getMethodOrFieldType() {
112 if (isInvocable())
113 return getMethodType();
114 if (isGetter())
115 return MethodType.methodType(getFieldType());
116 if (isSetter())
117 return MethodType.methodType(void.class, getFieldType());
118 throw new InternalError("not a method or field: "+this);
119 }
169 }
170 if (!isInvocable()) {
171 throw newIllegalArgumentException("not invocable, no method type");
172 }
173
174 // Get a snapshot of type which doesn't get changed by racing threads.
175 final Object type = this.type;
176 if (type instanceof String) {
177 return (String) type;
178 } else {
179 return getMethodType().toMethodDescriptorString();
180 }
181 }
182
183 /** Return the actual type under which this method or constructor must be invoked.
184 * For non-static methods or constructors, this is the type with a leading parameter,
185 * a reference to declaring class. For static methods, it is the same as the declared type.
186 */
187 public MethodType getInvocationType() {
188 MethodType itype = getMethodOrFieldType();
189 if (isConstructor() && getReferenceKind() == REF_newInvokeSpecial)
190 return itype.changeReturnType(clazz);
191 if (!isStatic())
192 return itype.insertParameterTypes(0, clazz);
193 return itype;
194 }
195
196 /** Return the declared type of this member, which
197 * must be a field or type.
198 * If it is a type member, that type itself is returned.
199 */
200 public Class<?> getFieldType() {
201 if (type == null) {
202 expandFromVM();
203 if (type == null) {
204 return null;
205 }
206 }
207 if (isInvocable()) {
208 throw newIllegalArgumentException("not a field or nested class, no simple type");
209 }
210
211 {
212 // Get a snapshot of type which doesn't get changed by racing threads.
235 }
236
237 /** Return the modifier flags of this member.
238 * @see java.lang.reflect.Modifier
239 */
240 public int getModifiers() {
241 return (flags & RECOGNIZED_MODIFIERS);
242 }
243
244 /** Return the reference kind of this member, or zero if none.
245 */
246 public byte getReferenceKind() {
247 return (byte) ((flags >>> MN_REFERENCE_KIND_SHIFT) & MN_REFERENCE_KIND_MASK);
248 }
249 private boolean referenceKindIsConsistent() {
250 byte refKind = getReferenceKind();
251 if (refKind == REF_NONE) return isType();
252 if (isField()) {
253 assert(staticIsConsistent());
254 assert(MethodHandleNatives.refKindIsField(refKind));
255 } else if (isConstructor()) {
256 assert(refKind == REF_newInvokeSpecial || refKind == REF_invokeSpecial);
257 } else if (isMethod()) {
258 assert(staticIsConsistent());
259 assert(MethodHandleNatives.refKindIsMethod(refKind));
260 if (clazz.isInterface())
261 assert(refKind == REF_invokeInterface ||
262 refKind == REF_invokeStatic ||
263 refKind == REF_invokeSpecial ||
264 refKind == REF_invokeVirtual && isObjectPublicMethod());
265 } else {
266 assert(false);
267 }
268 return true;
269 }
270 private boolean isObjectPublicMethod() {
271 if (clazz == Object.class) return true;
272 MethodType mtype = getMethodType();
273 if (name.equals("toString") && mtype.returnType() == String.class && mtype.parameterCount() == 0)
274 return true;
275 if (name.equals("hashCode") && mtype.returnType() == int.class && mtype.parameterCount() == 0)
375 private static final int MH_INVOKE_MODS = Modifier.NATIVE | Modifier.FINAL | Modifier.PUBLIC;
376
377 /** Utility method to query the modifier flags of this member. */
378 public boolean isStatic() {
379 return Modifier.isStatic(flags);
380 }
381 /** Utility method to query the modifier flags of this member. */
382 public boolean isPublic() {
383 return Modifier.isPublic(flags);
384 }
385 /** Utility method to query the modifier flags of this member. */
386 public boolean isPrivate() {
387 return Modifier.isPrivate(flags);
388 }
389 /** Utility method to query the modifier flags of this member. */
390 public boolean isProtected() {
391 return Modifier.isProtected(flags);
392 }
393 /** Utility method to query the modifier flags of this member. */
394 public boolean isFinal() {
395 return Modifier.isFinal(flags);
396 }
397 /** Utility method to query whether this member or its defining class is final. */
398 public boolean canBeStaticallyBound() {
399 return Modifier.isFinal(flags | clazz.getModifiers());
400 }
401 /** Utility method to query the modifier flags of this member. */
402 public boolean isVolatile() {
403 return Modifier.isVolatile(flags);
404 }
405 /** Utility method to query the modifier flags of this member. */
406 public boolean isAbstract() {
407 return Modifier.isAbstract(flags);
408 }
409 /** Utility method to query the modifier flags of this member. */
410 public boolean isNative() {
411 return Modifier.isNative(flags);
412 }
413 // let the rest (native, volatile, transient, etc.) be tested via Modifier.isFoo
414
415 // unofficial modifier flags, used by HotSpot:
416 static final int BRIDGE = 0x00000040;
417 static final int VARARGS = 0x00000080;
418 static final int SYNTHETIC = 0x00001000;
419 static final int ANNOTATION= 0x00002000;
420 static final int ENUM = 0x00004000;
421 /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
422 public boolean isBridge() {
423 return allFlagsSet(IS_METHOD | BRIDGE);
424 }
425 /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
426 public boolean isVarargs() {
427 return allFlagsSet(VARARGS) && isInvocable();
428 }
429 /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
430 public boolean isSynthetic() {
431 return allFlagsSet(SYNTHETIC);
432 }
433
434 static final String CONSTRUCTOR_NAME = "<init>"; // the ever-popular
435
436 // modifiers exported by the JVM:
437 static final int RECOGNIZED_MODIFIERS = 0xFFFF;
438
439 // private flags, not part of RECOGNIZED_MODIFIERS:
440 static final int
441 IS_METHOD = MN_IS_METHOD, // method (not constructor)
442 IS_CONSTRUCTOR = MN_IS_CONSTRUCTOR, // constructor
443 IS_FIELD = MN_IS_FIELD, // field
444 IS_TYPE = MN_IS_TYPE, // nested type
445 CALLER_SENSITIVE = MN_CALLER_SENSITIVE, // @CallerSensitive annotation detected
446 TRUSTED_FINAL = MN_TRUSTED_FINAL; // trusted final field
447
448 static final int ALL_ACCESS = Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED;
449 static final int ALL_KINDS = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE;
450 static final int IS_INVOCABLE = IS_METHOD | IS_CONSTRUCTOR;
451
452 /** Utility method to query whether this member is a method or constructor. */
453 public boolean isInvocable() {
454 return anyFlagSet(IS_INVOCABLE);
455 }
456 /** Query whether this member is a method. */
457 public boolean isMethod() {
458 return allFlagsSet(IS_METHOD);
459 }
460 /** Query whether this member is a constructor. */
461 public boolean isConstructor() {
462 return allFlagsSet(IS_CONSTRUCTOR);
463 }
464 /** Query whether this member is a field. */
465 public boolean isField() {
466 return allFlagsSet(IS_FIELD);
467 }
468 /** Query whether this member is a type. */
469 public boolean isType() {
470 return allFlagsSet(IS_TYPE);
471 }
472 /** Utility method to query whether this member is neither public, private, nor protected. */
473 public boolean isPackage() {
474 return !anyFlagSet(ALL_ACCESS);
475 }
476 /** Query whether this member has a CallerSensitive annotation. */
477 public boolean isCallerSensitive() {
478 return allFlagsSet(CALLER_SENSITIVE);
479 }
480 /** Query whether this member is a trusted final field. */
481 public boolean isTrustedFinalField() {
482 return allFlagsSet(TRUSTED_FINAL | IS_FIELD);
483 }
567 throw new AbstractMethodError(this.toString());
568 if (getReferenceKind() == REF_invokeVirtual)
569 changeReferenceKind(REF_invokeSpecial, REF_invokeVirtual);
570 else if (getReferenceKind() == REF_invokeInterface)
571 // invokeSpecial on a default method
572 changeReferenceKind(REF_invokeSpecial, REF_invokeInterface);
573 }
574 }
575 public MemberName asSpecial() {
576 switch (getReferenceKind()) {
577 case REF_invokeSpecial: return this;
578 case REF_invokeVirtual: return clone().changeReferenceKind(REF_invokeSpecial, REF_invokeVirtual);
579 case REF_invokeInterface: return clone().changeReferenceKind(REF_invokeSpecial, REF_invokeInterface);
580 case REF_newInvokeSpecial: return clone().changeReferenceKind(REF_invokeSpecial, REF_newInvokeSpecial);
581 }
582 throw new IllegalArgumentException(this.toString());
583 }
584 /** If this MN is not REF_newInvokeSpecial, return a clone with that ref. kind.
585 * In that case it must already be REF_invokeSpecial.
586 */
587 public MemberName asConstructor() {
588 switch (getReferenceKind()) {
589 case REF_invokeSpecial: return clone().changeReferenceKind(REF_newInvokeSpecial, REF_invokeSpecial);
590 case REF_newInvokeSpecial: return this;
591 }
592 throw new IllegalArgumentException(this.toString());
593 }
594 /** If this MN is a REF_invokeSpecial, return a clone with the "normal" kind
595 * REF_invokeVirtual; also switch either to REF_invokeInterface if clazz.isInterface.
596 * The end result is to get a fully virtualized version of the MN.
597 * (Note that resolving in the JVM will sometimes devirtualize, changing
598 * REF_invokeVirtual of a final to REF_invokeSpecial, and REF_invokeInterface
599 * in some corner cases to either of the previous two; this transform
600 * undoes that change under the assumption that it occurred.)
601 */
602 public MemberName asNormalOriginal() {
603 byte refKind = getReferenceKind();
604 byte newRefKind = switch (refKind) {
605 case REF_invokeInterface,
606 REF_invokeVirtual,
607 REF_invokeSpecial -> clazz.isInterface() ? REF_invokeInterface : REF_invokeVirtual;
608 default -> refKind;
609 };
610 if (newRefKind == refKind)
611 return this;
612 MemberName result = clone().changeReferenceKind(newRefKind, refKind);
613 assert(this.referenceKindIsConsistentWith(result.getReferenceKind()));
614 return result;
615 }
616 /** Create a name for the given reflected constructor. The resulting name will be in a resolved state. */
617 @SuppressWarnings("LeakingThisInConstructor")
618 public MemberName(Constructor<?> ctor) {
619 Objects.requireNonNull(ctor);
620 // fill in vmtarget, vmindex while we have ctor in hand:
621 MethodHandleNatives.init(this, ctor);
622 assert(isResolved() && this.clazz != null);
623 this.name = CONSTRUCTOR_NAME;
624 if (this.type == null)
625 this.type = new Object[] { void.class, ctor.getParameterTypes() };
626 }
627 /** Create a name for the given reflected field. The resulting name will be in a resolved state.
628 */
629 public MemberName(Field fld) {
630 this(fld, false);
631 }
632 static {
633 // the following MemberName constructor relies on these ranges matching up
634 assert((REF_putStatic - REF_getStatic) == (REF_putField - REF_getField));
635 }
636 @SuppressWarnings("LeakingThisInConstructor")
637 public MemberName(Field fld, boolean makeSetter) {
638 Objects.requireNonNull(fld);
639 // fill in vmtarget, vmindex while we have fld in hand:
640 MethodHandleNatives.init(this, fld);
641 assert(isResolved() && this.clazz != null);
642 this.name = fld.getName();
643 this.type = fld.getType();
644 byte refKind = this.getReferenceKind();
645 assert(refKind == (isStatic() ? REF_getStatic : REF_getField));
737 if (this == that) return true;
738 if (that == null) return false;
739 return this.clazz == that.clazz
740 && this.getReferenceKind() == that.getReferenceKind()
741 && Objects.equals(this.name, that.name)
742 && Objects.equals(this.getType(), that.getType());
743 }
744
745 // Construction from symbolic parts, for queries:
746 /** Create a field or type name from the given components:
747 * Declaring class, name, type, reference kind.
748 * The declaring class may be supplied as null if this is to be a bare name and type.
749 * The resulting name will in an unresolved state.
750 */
751 public MemberName(Class<?> defClass, String name, Class<?> type, byte refKind) {
752 init(defClass, name, type, flagsMods(IS_FIELD, 0, refKind));
753 initResolved(false);
754 }
755 /** Create a method or constructor name from the given components:
756 * Declaring class, name, type, reference kind.
757 * It will be a constructor if and only if the name is {@code "<init>"}.
758 * The declaring class may be supplied as null if this is to be a bare name and type.
759 * The last argument is optional, a boolean which requests REF_invokeSpecial.
760 * The resulting name will in an unresolved state.
761 */
762 public MemberName(Class<?> defClass, String name, MethodType type, byte refKind) {
763 int initFlags = (name != null && name.equals(CONSTRUCTOR_NAME) ? IS_CONSTRUCTOR : IS_METHOD);
764 init(defClass, name, type, flagsMods(initFlags, 0, refKind));
765 initResolved(false);
766 }
767 /** Create a method, constructor, or field name from the given components:
768 * Reference kind, declaring class, name, type.
769 */
770 public MemberName(byte refKind, Class<?> defClass, String name, Object type) {
771 int kindFlags;
772 if (MethodHandleNatives.refKindIsField(refKind)) {
773 kindFlags = IS_FIELD;
774 if (!(type instanceof Class))
775 throw newIllegalArgumentException("not a field type");
776 } else if (MethodHandleNatives.refKindIsMethod(refKind)) {
777 kindFlags = IS_METHOD;
778 if (!(type instanceof MethodType))
779 throw newIllegalArgumentException("not a method type");
780 } else if (refKind == REF_newInvokeSpecial) {
781 kindFlags = IS_CONSTRUCTOR;
782 if (!(type instanceof MethodType) ||
783 !CONSTRUCTOR_NAME.equals(name))
784 throw newIllegalArgumentException("not a constructor type or name");
785 } else {
786 throw newIllegalArgumentException("bad reference kind "+refKind);
787 }
788 init(defClass, name, type, flagsMods(kindFlags, 0, refKind));
789 initResolved(false);
790 }
791
792 /** Query whether this member name is resolved.
793 * A resolved member name is one for which the JVM has found
794 * a method, constructor, field, or type binding corresponding exactly to the name.
795 * (Document?)
796 */
797 public boolean isResolved() {
798 return resolution == null;
799 }
800
801 void initResolved(boolean isResolved) {
879 if (from instanceof MethodHandles.Lookup lookup) {
880 from = lookup.lookupClass();
881 m = lookup.lookupClass().getModule();
882 plc = lookup.previousLookupClass();
883 } else {
884 m = ((Class<?>)from).getModule();
885 plc = null;
886 }
887 message += ", from " + from + " (" + m + ")";
888 if (plc != null) {
889 message += ", previous lookup " +
890 plc.getName() + " (" + plc.getModule() + ")";
891 }
892 }
893 }
894 return new IllegalAccessException(message);
895 }
896 private String message() {
897 if (isResolved())
898 return "no access";
899 else if (isConstructor())
900 return "no such constructor";
901 else if (isMethod())
902 return "no such method";
903 else
904 return "no such field";
905 }
906 public ReflectiveOperationException makeAccessException() {
907 String message = message() + ": " + this;
908 ReflectiveOperationException ex;
909 if (isResolved() || !(resolution instanceof NoSuchMethodError ||
910 resolution instanceof NoSuchFieldError))
911 ex = new IllegalAccessException(message);
912 else if (isConstructor())
913 ex = new NoSuchMethodException(message);
914 else if (isMethod())
915 ex = new NoSuchMethodException(message);
916 else
917 ex = new NoSuchFieldException(message);
918 if (resolution instanceof Throwable)
919 ex.initCause((Throwable) resolution);
920 return ex;
921 }
922
923 /** Actually making a query requires an access check. */
924 /*non-public*/
925 static Factory getFactory() {
926 return Factory.INSTANCE;
927 }
928 /** A factory type for resolving member names with the help of the VM.
929 * TBD: Define access-safe public constructors for this factory.
930 */
931 /*non-public*/
932 static class Factory {
|
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.invoke;
27
28 import jdk.internal.value.PrimitiveClass;
29 import sun.invoke.util.VerifyAccess;
30
31 import java.lang.reflect.Constructor;
32 import java.lang.reflect.Field;
33 import java.lang.reflect.Member;
34 import java.lang.reflect.Method;
35 import java.lang.reflect.Modifier;
36 import java.util.Objects;
37
38 import static java.lang.invoke.MethodHandleNatives.Constants.*;
39 import static java.lang.invoke.MethodHandleStatics.newIllegalArgumentException;
40 import static java.lang.invoke.MethodHandleStatics.newInternalError;
41
42 /**
43 * A {@code MemberName} is a compact symbolic datum which fully characterizes
44 * a method or field reference.
45 * A member name refers to a field, method, constructor, or member type.
46 * Every member name has a simple name (a string) and a type (either a Class or MethodType).
47 * A member name may also have a non-null declaring class, or it may be simply
48 * a naked name/type pair.
80 private int flags; // modifier bits; see reflect.Modifier
81 private ResolvedMethodName method; // cached resolved method information
82 //@Injected intptr_t vmindex; // vtable index or offset of resolved member
83 Object resolution; // if null, this guy is resolved
84
85 /** Return the declaring class of this member.
86 * In the case of a bare name and type, the declaring class will be null.
87 */
88 public Class<?> getDeclaringClass() {
89 return clazz;
90 }
91
92 /** Utility method producing the class loader of the declaring class. */
93 public ClassLoader getClassLoader() {
94 return clazz.getClassLoader();
95 }
96
97 /** Return the simple name of this member.
98 * For a type, it is the same as {@link Class#getSimpleName}.
99 * For a method or field, it is the simple name of the member.
100 * For an identity object constructor, it is {@code "<init>"}.
101 * For a value class static factory method, it is {@code "<vnew>"}.
102 */
103 public String getName() {
104 if (name == null) {
105 expandFromVM();
106 if (name == null) {
107 return null;
108 }
109 }
110 return name;
111 }
112
113 public MethodType getMethodOrFieldType() {
114 if (isInvocable())
115 return getMethodType();
116 if (isGetter())
117 return MethodType.methodType(getFieldType());
118 if (isSetter())
119 return MethodType.methodType(void.class, getFieldType());
120 throw new InternalError("not a method or field: "+this);
121 }
171 }
172 if (!isInvocable()) {
173 throw newIllegalArgumentException("not invocable, no method type");
174 }
175
176 // Get a snapshot of type which doesn't get changed by racing threads.
177 final Object type = this.type;
178 if (type instanceof String) {
179 return (String) type;
180 } else {
181 return getMethodType().toMethodDescriptorString();
182 }
183 }
184
185 /** Return the actual type under which this method or constructor must be invoked.
186 * For non-static methods or constructors, this is the type with a leading parameter,
187 * a reference to declaring class. For static methods, it is the same as the declared type.
188 */
189 public MethodType getInvocationType() {
190 MethodType itype = getMethodOrFieldType();
191 Class<?> c = PrimitiveClass.isPrimitiveClass(clazz) ? PrimitiveClass.asValueType(clazz) : clazz;
192 if (isObjectConstructor() && getReferenceKind() == REF_newInvokeSpecial)
193 return itype.changeReturnType(c);
194 if (!isStatic())
195 return itype.insertParameterTypes(0, c);
196 return itype;
197 }
198
199 /** Return the declared type of this member, which
200 * must be a field or type.
201 * If it is a type member, that type itself is returned.
202 */
203 public Class<?> getFieldType() {
204 if (type == null) {
205 expandFromVM();
206 if (type == null) {
207 return null;
208 }
209 }
210 if (isInvocable()) {
211 throw newIllegalArgumentException("not a field or nested class, no simple type");
212 }
213
214 {
215 // Get a snapshot of type which doesn't get changed by racing threads.
238 }
239
240 /** Return the modifier flags of this member.
241 * @see java.lang.reflect.Modifier
242 */
243 public int getModifiers() {
244 return (flags & RECOGNIZED_MODIFIERS);
245 }
246
247 /** Return the reference kind of this member, or zero if none.
248 */
249 public byte getReferenceKind() {
250 return (byte) ((flags >>> MN_REFERENCE_KIND_SHIFT) & MN_REFERENCE_KIND_MASK);
251 }
252 private boolean referenceKindIsConsistent() {
253 byte refKind = getReferenceKind();
254 if (refKind == REF_NONE) return isType();
255 if (isField()) {
256 assert(staticIsConsistent());
257 assert(MethodHandleNatives.refKindIsField(refKind));
258 } else if (isObjectConstructor()) {
259 assert(refKind == REF_newInvokeSpecial || refKind == REF_invokeSpecial);
260 } else if (isMethod()) {
261 assert(staticIsConsistent());
262 assert(MethodHandleNatives.refKindIsMethod(refKind));
263 if (clazz.isInterface())
264 assert(refKind == REF_invokeInterface ||
265 refKind == REF_invokeStatic ||
266 refKind == REF_invokeSpecial ||
267 refKind == REF_invokeVirtual && isObjectPublicMethod());
268 } else {
269 assert(false);
270 }
271 return true;
272 }
273 private boolean isObjectPublicMethod() {
274 if (clazz == Object.class) return true;
275 MethodType mtype = getMethodType();
276 if (name.equals("toString") && mtype.returnType() == String.class && mtype.parameterCount() == 0)
277 return true;
278 if (name.equals("hashCode") && mtype.returnType() == int.class && mtype.parameterCount() == 0)
378 private static final int MH_INVOKE_MODS = Modifier.NATIVE | Modifier.FINAL | Modifier.PUBLIC;
379
380 /** Utility method to query the modifier flags of this member. */
381 public boolean isStatic() {
382 return Modifier.isStatic(flags);
383 }
384 /** Utility method to query the modifier flags of this member. */
385 public boolean isPublic() {
386 return Modifier.isPublic(flags);
387 }
388 /** Utility method to query the modifier flags of this member. */
389 public boolean isPrivate() {
390 return Modifier.isPrivate(flags);
391 }
392 /** Utility method to query the modifier flags of this member. */
393 public boolean isProtected() {
394 return Modifier.isProtected(flags);
395 }
396 /** Utility method to query the modifier flags of this member. */
397 public boolean isFinal() {
398 // all fields declared in a value type are effectively final
399 assert(!clazz.isValue() || !isField() || Modifier.isFinal(flags));
400 return Modifier.isFinal(flags);
401 }
402 /** Utility method to query whether this member or its defining class is final. */
403 public boolean canBeStaticallyBound() {
404 return Modifier.isFinal(flags | clazz.getModifiers());
405 }
406 /** Utility method to query the modifier flags of this member. */
407 public boolean isVolatile() {
408 return Modifier.isVolatile(flags);
409 }
410 /** Utility method to query the modifier flags of this member. */
411 public boolean isAbstract() {
412 return Modifier.isAbstract(flags);
413 }
414 /** Utility method to query the modifier flags of this member. */
415 public boolean isNative() {
416 return Modifier.isNative(flags);
417 }
418 // let the rest (native, volatile, transient, etc.) be tested via Modifier.isFoo
419
420 // unofficial modifier flags, used by HotSpot:
421 static final int BRIDGE = 0x00000040;
422 static final int VARARGS = 0x00000080;
423 static final int SYNTHETIC = 0x00001000;
424 static final int ANNOTATION = 0x00002000;
425 static final int ENUM = 0x00004000;
426
427 /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
428 public boolean isBridge() {
429 return allFlagsSet(IS_METHOD | BRIDGE);
430 }
431 /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
432 public boolean isVarargs() {
433 return allFlagsSet(VARARGS) && isInvocable();
434 }
435 /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
436 public boolean isSynthetic() {
437 return allFlagsSet(SYNTHETIC);
438 }
439
440 /** Query whether this member is a flattened field */
441 public boolean isFlattened() { return (flags & MN_FLATTENED) == MN_FLATTENED; }
442
443 /** Query whether this member is a field of a primitive class. */
444 public boolean isInlineableField() {
445 if (isField()) {
446 Class<?> type = getFieldType();
447 return PrimitiveClass.isPrimitiveValueType(type) || (type.isValue() && !PrimitiveClass.isPrimitiveClass(type));
448 }
449 return false;
450 }
451
452 static final String CONSTRUCTOR_NAME = "<init>";
453 static final String VALUE_FACTORY_NAME = "<vnew>"; // the ever-popular
454
455 // modifiers exported by the JVM:
456 static final int RECOGNIZED_MODIFIERS = 0xFFFF;
457
458 // private flags, not part of RECOGNIZED_MODIFIERS:
459 static final int
460 IS_METHOD = MN_IS_METHOD, // method (not object constructor)
461 IS_OBJECT_CONSTRUCTOR = MN_IS_OBJECT_CONSTRUCTOR, // object constructor
462 IS_FIELD = MN_IS_FIELD, // field
463 IS_TYPE = MN_IS_TYPE, // nested type
464 CALLER_SENSITIVE = MN_CALLER_SENSITIVE, // @CallerSensitive annotation detected
465 TRUSTED_FINAL = MN_TRUSTED_FINAL; // trusted final field
466
467 static final int ALL_ACCESS = Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED;
468 static final int ALL_KINDS = IS_METHOD | IS_OBJECT_CONSTRUCTOR | IS_FIELD | IS_TYPE;
469 static final int IS_INVOCABLE = IS_METHOD | IS_OBJECT_CONSTRUCTOR;
470
471 /** Utility method to query whether this member is a method or constructor. */
472 public boolean isInvocable() {
473 return anyFlagSet(IS_INVOCABLE);
474 }
475 /** Query whether this member is a method. */
476 public boolean isMethod() {
477 return allFlagsSet(IS_METHOD);
478 }
479 /** Query whether this member is a constructor. */
480 public boolean isObjectConstructor() {
481 return allFlagsSet(IS_OBJECT_CONSTRUCTOR);
482 }
483 /** Query whether this member is an object constructor or static <init> factory */
484 public boolean isStaticValueFactoryMethod() {
485 return VALUE_FACTORY_NAME.equals(name) && isMethod();
486 }
487
488 /** Query whether this member is a field. */
489 public boolean isField() {
490 return allFlagsSet(IS_FIELD);
491 }
492 /** Query whether this member is a type. */
493 public boolean isType() {
494 return allFlagsSet(IS_TYPE);
495 }
496 /** Utility method to query whether this member is neither public, private, nor protected. */
497 public boolean isPackage() {
498 return !anyFlagSet(ALL_ACCESS);
499 }
500 /** Query whether this member has a CallerSensitive annotation. */
501 public boolean isCallerSensitive() {
502 return allFlagsSet(CALLER_SENSITIVE);
503 }
504 /** Query whether this member is a trusted final field. */
505 public boolean isTrustedFinalField() {
506 return allFlagsSet(TRUSTED_FINAL | IS_FIELD);
507 }
591 throw new AbstractMethodError(this.toString());
592 if (getReferenceKind() == REF_invokeVirtual)
593 changeReferenceKind(REF_invokeSpecial, REF_invokeVirtual);
594 else if (getReferenceKind() == REF_invokeInterface)
595 // invokeSpecial on a default method
596 changeReferenceKind(REF_invokeSpecial, REF_invokeInterface);
597 }
598 }
599 public MemberName asSpecial() {
600 switch (getReferenceKind()) {
601 case REF_invokeSpecial: return this;
602 case REF_invokeVirtual: return clone().changeReferenceKind(REF_invokeSpecial, REF_invokeVirtual);
603 case REF_invokeInterface: return clone().changeReferenceKind(REF_invokeSpecial, REF_invokeInterface);
604 case REF_newInvokeSpecial: return clone().changeReferenceKind(REF_invokeSpecial, REF_newInvokeSpecial);
605 }
606 throw new IllegalArgumentException(this.toString());
607 }
608 /** If this MN is not REF_newInvokeSpecial, return a clone with that ref. kind.
609 * In that case it must already be REF_invokeSpecial.
610 */
611 public MemberName asObjectConstructor() {
612 switch (getReferenceKind()) {
613 case REF_invokeSpecial: return clone().changeReferenceKind(REF_newInvokeSpecial, REF_invokeSpecial);
614 case REF_newInvokeSpecial: return this;
615 }
616 throw new IllegalArgumentException(this.toString());
617 }
618 /** If this MN is a REF_invokeSpecial, return a clone with the "normal" kind
619 * REF_invokeVirtual; also switch either to REF_invokeInterface if clazz.isInterface.
620 * The end result is to get a fully virtualized version of the MN.
621 * (Note that resolving in the JVM will sometimes devirtualize, changing
622 * REF_invokeVirtual of a final to REF_invokeSpecial, and REF_invokeInterface
623 * in some corner cases to either of the previous two; this transform
624 * undoes that change under the assumption that it occurred.)
625 */
626 public MemberName asNormalOriginal() {
627 byte refKind = getReferenceKind();
628 byte newRefKind = switch (refKind) {
629 case REF_invokeInterface,
630 REF_invokeVirtual,
631 REF_invokeSpecial -> clazz.isInterface() ? REF_invokeInterface : REF_invokeVirtual;
632 default -> refKind;
633 };
634 if (newRefKind == refKind)
635 return this;
636 MemberName result = clone().changeReferenceKind(newRefKind, refKind);
637 assert(this.referenceKindIsConsistentWith(result.getReferenceKind()));
638 return result;
639 }
640 /** Create a name for the given reflected constructor. The resulting name will be in a resolved state. */
641 @SuppressWarnings("LeakingThisInConstructor")
642 public MemberName(Constructor<?> ctor) {
643 Objects.requireNonNull(ctor);
644 // fill in vmtarget, vmindex while we have ctor in hand:
645 MethodHandleNatives.init(this, ctor);
646 assert(isResolved() && this.clazz != null);
647 this.name = this.clazz.isValue() ? VALUE_FACTORY_NAME : CONSTRUCTOR_NAME;
648 if (this.type == null) {
649 Class<?> rtype = void.class;
650 if (isStatic()) { // a value class static factory, not a true constructor
651 rtype = getDeclaringClass();
652 }
653 this.type = new Object[] { rtype, ctor.getParameterTypes() };
654 }
655 }
656 /** Create a name for the given reflected field. The resulting name will be in a resolved state.
657 */
658 public MemberName(Field fld) {
659 this(fld, false);
660 }
661 static {
662 // the following MemberName constructor relies on these ranges matching up
663 assert((REF_putStatic - REF_getStatic) == (REF_putField - REF_getField));
664 }
665 @SuppressWarnings("LeakingThisInConstructor")
666 public MemberName(Field fld, boolean makeSetter) {
667 Objects.requireNonNull(fld);
668 // fill in vmtarget, vmindex while we have fld in hand:
669 MethodHandleNatives.init(this, fld);
670 assert(isResolved() && this.clazz != null);
671 this.name = fld.getName();
672 this.type = fld.getType();
673 byte refKind = this.getReferenceKind();
674 assert(refKind == (isStatic() ? REF_getStatic : REF_getField));
766 if (this == that) return true;
767 if (that == null) return false;
768 return this.clazz == that.clazz
769 && this.getReferenceKind() == that.getReferenceKind()
770 && Objects.equals(this.name, that.name)
771 && Objects.equals(this.getType(), that.getType());
772 }
773
774 // Construction from symbolic parts, for queries:
775 /** Create a field or type name from the given components:
776 * Declaring class, name, type, reference kind.
777 * The declaring class may be supplied as null if this is to be a bare name and type.
778 * The resulting name will in an unresolved state.
779 */
780 public MemberName(Class<?> defClass, String name, Class<?> type, byte refKind) {
781 init(defClass, name, type, flagsMods(IS_FIELD, 0, refKind));
782 initResolved(false);
783 }
784 /** Create a method or constructor name from the given components:
785 * Declaring class, name, type, reference kind.
786 * It will be an object constructor if and only if the name is {@code "<init>"}.
787 * It will be a value class instance factory method if and only if the name is {@code "<vnew>"}.
788 * The declaring class may be supplied as null if this is to be a bare name and type.
789 * The last argument is optional, a boolean which requests REF_invokeSpecial.
790 * The resulting name will in an unresolved state.
791 */
792 public MemberName(Class<?> defClass, String name, MethodType type, byte refKind) {
793 int initFlags = CONSTRUCTOR_NAME.equals(name) ? IS_OBJECT_CONSTRUCTOR : IS_METHOD;
794 init(defClass, name, type, flagsMods(initFlags, 0, refKind));
795 initResolved(false);
796 }
797 /** Create a method, constructor, or field name from the given components:
798 * Reference kind, declaring class, name, type.
799 */
800 public MemberName(byte refKind, Class<?> defClass, String name, Object type) {
801 int kindFlags;
802 if (MethodHandleNatives.refKindIsField(refKind)) {
803 kindFlags = IS_FIELD;
804 if (!(type instanceof Class))
805 throw newIllegalArgumentException("not a field type");
806 } else if (MethodHandleNatives.refKindIsMethod(refKind)) {
807 kindFlags = IS_METHOD;
808 if (!(type instanceof MethodType))
809 throw newIllegalArgumentException("not a method type");
810 } else if (refKind == REF_newInvokeSpecial) {
811 kindFlags = IS_OBJECT_CONSTRUCTOR;
812 if (!(type instanceof MethodType) ||
813 !CONSTRUCTOR_NAME.equals(name))
814 throw newIllegalArgumentException("not a constructor type or name");
815 } else {
816 throw newIllegalArgumentException("bad reference kind "+refKind);
817 }
818 init(defClass, name, type, flagsMods(kindFlags, 0, refKind));
819 initResolved(false);
820 }
821
822 /** Query whether this member name is resolved.
823 * A resolved member name is one for which the JVM has found
824 * a method, constructor, field, or type binding corresponding exactly to the name.
825 * (Document?)
826 */
827 public boolean isResolved() {
828 return resolution == null;
829 }
830
831 void initResolved(boolean isResolved) {
909 if (from instanceof MethodHandles.Lookup lookup) {
910 from = lookup.lookupClass();
911 m = lookup.lookupClass().getModule();
912 plc = lookup.previousLookupClass();
913 } else {
914 m = ((Class<?>)from).getModule();
915 plc = null;
916 }
917 message += ", from " + from + " (" + m + ")";
918 if (plc != null) {
919 message += ", previous lookup " +
920 plc.getName() + " (" + plc.getModule() + ")";
921 }
922 }
923 }
924 return new IllegalAccessException(message);
925 }
926 private String message() {
927 if (isResolved())
928 return "no access";
929 else if (isObjectConstructor())
930 return "no such constructor";
931 else if (isMethod())
932 return "no such method";
933 else
934 return "no such field";
935 }
936 public ReflectiveOperationException makeAccessException() {
937 String message = message() + ": " + this;
938 ReflectiveOperationException ex;
939 if (isResolved() || !(resolution instanceof NoSuchMethodError ||
940 resolution instanceof NoSuchFieldError))
941 ex = new IllegalAccessException(message);
942 else if (isObjectConstructor())
943 ex = new NoSuchMethodException(message);
944 else if (isMethod())
945 ex = new NoSuchMethodException(message);
946 else
947 ex = new NoSuchFieldException(message);
948 if (resolution instanceof Throwable)
949 ex.initCause((Throwable) resolution);
950 return ex;
951 }
952
953 /** Actually making a query requires an access check. */
954 /*non-public*/
955 static Factory getFactory() {
956 return Factory.INSTANCE;
957 }
958 /** A factory type for resolving member names with the help of the VM.
959 * TBD: Define access-safe public constructors for this factory.
960 */
961 /*non-public*/
962 static class Factory {
|