Skip to content

Commit 7bf1989

Browse files
Vicente Romeroliach
Vicente Romero
and
liach
committedMay 24, 2024
8320575: generic type information lost on mandated parameters of record's compact constructors
Co-authored-by: Chen Liang <liach@openjdk.org> Reviewed-by: jlahoda
·
jdk-25+17jdk-23-ga
1 parent 253508b commit 7bf1989

File tree

3 files changed

+399
-29
lines changed

3 files changed

+399
-29
lines changed
 

‎src/java.base/share/classes/java/lang/reflect/Executable.java

+61-24
Original file line numberDiff line numberDiff line change
@@ -255,12 +255,17 @@ public Set<AccessFlag> accessFlags() {
255255
* represented by this object. Returns an array of length
256256
* 0 if the underlying executable takes no parameters.
257257
* Note that the constructors of some inner classes
258-
* may have an implicitly declared parameter in addition to
259-
* explicitly declared ones.
258+
* may have an {@linkplain java.compiler/javax.lang.model.util.Elements.Origin#MANDATED
259+
* implicitly declared} parameter in addition to explicitly
260+
* declared ones.
261+
* Also note that compact constructors of a record class may have
262+
* {@linkplain java.compiler/javax.lang.model.util.Elements.Origin#MANDATED
263+
* implicitly declared} parameters.
260264
*
261265
* @return the parameter types for the executable this object
262266
* represents
263267
*/
268+
@SuppressWarnings("doclint:reference") // cross-module links
264269
public abstract Class<?>[] getParameterTypes();
265270

266271
/**
@@ -280,18 +285,32 @@ public Set<AccessFlag> accessFlags() {
280285
* underlying executable takes no parameters. Note that the
281286
* constructors of some inner classes may have an implicitly
282287
* declared parameter in addition to explicitly declared ones.
283-
* Also note that as a <a
284-
* href="{@docRoot}/java.base/java/lang/reflect/package-summary.html#LanguageJvmModel">modeling
285-
* artifact</a>, the number of returned parameters can differ
288+
* Compact constructors of a record class may also have
289+
* {@linkplain java.compiler/javax.lang.model.util.Elements.Origin#MANDATED
290+
* implicitly declared} parameters,
291+
* but they are a special case and thus considered as if they had
292+
* been explicitly declared in the source.
293+
* Finally note that as a {@link java.lang.reflect##LanguageJvmModel
294+
* modeling artifact}, the number of returned parameters can differ
286295
* depending on whether or not generic information is present. If
287-
* generic information is present, only parameters explicitly
288-
* present in the source will be returned; if generic information
289-
* is not present, implicit and synthetic parameters may be
296+
* generic information is present, parameters explicitly
297+
* present in the source or parameters of compact constructors
298+
* of a record class will be returned.
299+
* Note that parameters of compact constructors of a record class are a special case,
300+
* as they are not explicitly present in the source, and its type will be returned
301+
* regardless of the parameters being
302+
* {@linkplain java.compiler/javax.lang.model.util.Elements.Origin#MANDATED
303+
* implicitly declared} or not.
304+
* If generic information is not present, implicit and synthetic parameters may be
290305
* returned as well.
291306
*
292307
* <p>If a formal parameter type is a parameterized type,
293308
* the {@code Type} object returned for it must accurately reflect
294-
* the actual type arguments used in the source code.
309+
* the actual type arguments used in the source code. This assertion also
310+
* applies to the parameters of compact constructors of a record class,
311+
* independently of them being
312+
* {@linkplain java.compiler/javax.lang.model.util.Elements.Origin#MANDATED
313+
* implicitly declared} or not.
295314
*
296315
* <p>If a formal parameter type is a type variable or a parameterized
297316
* type, it is created. Otherwise, it is resolved.
@@ -309,6 +328,7 @@ public Set<AccessFlag> accessFlags() {
309328
* the underlying executable's parameter types refer to a parameterized
310329
* type that cannot be instantiated for any reason
311330
*/
331+
@SuppressWarnings("doclint:reference") // cross-module links
312332
public Type[] getGenericParameterTypes() {
313333
if (hasGenericInformation())
314334
return getGenericInfo().getParameterTypes();
@@ -335,22 +355,34 @@ Type[] getAllGenericParameterTypes() {
335355
// If we have real parameter data, then we use the
336356
// synthetic and mandate flags to our advantage.
337357
if (realParamData) {
338-
final Type[] out = new Type[nonGenericParamTypes.length];
339-
final Parameter[] params = getParameters();
340-
int fromidx = 0;
341-
for (int i = 0; i < out.length; i++) {
342-
final Parameter param = params[i];
343-
if (param.isSynthetic() || param.isImplicit()) {
344-
// If we hit a synthetic or mandated parameter,
345-
// use the non generic parameter info.
346-
out[i] = nonGenericParamTypes[i];
358+
if (getDeclaringClass().isRecord() && this instanceof Constructor) {
359+
/* we could be seeing a compact constructor of a record class
360+
* its parameters are mandated but we should be able to retrieve
361+
* its generic information if present
362+
*/
363+
if (genericParamTypes.length == nonGenericParamTypes.length) {
364+
return genericParamTypes;
347365
} else {
348-
// Otherwise, use the generic parameter info.
349-
out[i] = genericParamTypes[fromidx];
350-
fromidx++;
366+
return nonGenericParamTypes.clone();
351367
}
368+
} else {
369+
final Type[] out = new Type[nonGenericParamTypes.length];
370+
final Parameter[] params = getParameters();
371+
int fromidx = 0;
372+
for (int i = 0; i < out.length; i++) {
373+
final Parameter param = params[i];
374+
if (param.isSynthetic() || param.isImplicit()) {
375+
// If we hit a synthetic or mandated parameter,
376+
// use the non generic parameter info.
377+
out[i] = nonGenericParamTypes[i];
378+
} else {
379+
// Otherwise, use the generic parameter info.
380+
out[i] = genericParamTypes[fromidx];
381+
fromidx++;
382+
}
383+
}
384+
return out;
352385
}
353-
return out;
354386
} else {
355387
// Otherwise, use the non-generic parameter data.
356388
// Without method parameter reflection data, we have
@@ -748,13 +780,18 @@ Type parameterize(Class<?> c) {
748780
* Returns an array of length 0 if the method/constructor declares no
749781
* parameters.
750782
* Note that the constructors of some inner classes
751-
* may have an implicitly declared parameter in addition to
752-
* explicitly declared ones.
783+
* may have an
784+
* {@linkplain java.compiler/javax.lang.model.util.Elements.Origin#MANDATED
785+
* implicitly declared} parameter in addition to explicitly declared ones.
786+
* Also note that compact constructors of a record class may have
787+
* {@linkplain java.compiler/javax.lang.model.util.Elements.Origin#MANDATED
788+
* implicitly declared} parameters.
753789
*
754790
* @return an array of objects representing the types of the
755791
* formal parameters of the method or constructor represented by this
756792
* {@code Executable}
757793
*/
794+
@SuppressWarnings("doclint:reference") // cross-module links
758795
public AnnotatedType[] getAnnotatedParameterTypes() {
759796
return TypeAnnotationParser.buildAnnotatedTypes(getTypeAnnotationBytes0(),
760797
SharedSecrets.getJavaLangAccess().

‎test/jdk/java/lang/reflect/records/R10.jcod

+262
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,262 @@
1+
// this record is defined as:
2+
// record R10(List<String> ls) { // there is no compact constructor and thus there is no mandated param
3+
// }
4+
class R10 {
5+
0xCAFEBABE;
6+
0; // minor version
7+
64; // version
8+
[] { // Constant Pool
9+
; // first element is empty
10+
Method #2 #3; // #1
11+
class #4; // #2
12+
NameAndType #5 #6; // #3
13+
Utf8 "java/lang/Record"; // #4
14+
Utf8 "<init>"; // #5
15+
Utf8 "()V"; // #6
16+
Field #8 #9; // #7
17+
class #10; // #8
18+
NameAndType #11 #12; // #9
19+
Utf8 "R10"; // #10
20+
Utf8 "ls"; // #11
21+
Utf8 "Ljava/util/List;"; // #12
22+
InvokeDynamic 0s #14; // #13
23+
NameAndType #15 #16; // #14
24+
Utf8 "toString"; // #15
25+
Utf8 "(LR10;)Ljava/lang/String;"; // #16
26+
InvokeDynamic 0s #18; // #17
27+
NameAndType #19 #20; // #18
28+
Utf8 "hashCode"; // #19
29+
Utf8 "(LR10;)I"; // #20
30+
InvokeDynamic 0s #22; // #21
31+
NameAndType #23 #24; // #22
32+
Utf8 "equals"; // #23
33+
Utf8 "(LR10;Ljava/lang/Object;)Z"; // #24
34+
Utf8 "Signature"; // #25
35+
Utf8 "Ljava/util/List<Ljava/lang/String;>;"; // #26
36+
Utf8 "(Ljava/util/List;)V"; // #27
37+
Utf8 "Code"; // #28
38+
Utf8 "LineNumberTable"; // #29
39+
Utf8 "MethodParameters"; // #30
40+
Utf8 "(Ljava/util/List<Ljava/lang/String;>;)V"; // #31
41+
Utf8 "()Ljava/lang/String;"; // #32
42+
Utf8 "()I"; // #33
43+
Utf8 "(Ljava/lang/Object;)Z"; // #34
44+
Utf8 "()Ljava/util/List;"; // #35
45+
Utf8 "()Ljava/util/List<Ljava/lang/String;>;"; // #36
46+
Utf8 "SourceFile"; // #37
47+
Utf8 "R10.java"; // #38
48+
Utf8 "Record"; // #39
49+
Utf8 "BootstrapMethods"; // #40
50+
MethodHandle 6b #42; // #41
51+
Method #43 #44; // #42
52+
class #45; // #43
53+
NameAndType #46 #47; // #44
54+
Utf8 "java/lang/runtime/ObjectMethods"; // #45
55+
Utf8 "bootstrap"; // #46
56+
Utf8 "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/TypeDescriptor;Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/invoke/MethodHandle;)Ljava/lang/Object;"; // #47
57+
String #11; // #48
58+
MethodHandle 1b #7; // #49
59+
Utf8 "InnerClasses"; // #50
60+
class #52; // #51
61+
Utf8 "java/lang/invoke/MethodHandles$Lookup"; // #52
62+
class #54; // #53
63+
Utf8 "java/lang/invoke/MethodHandles"; // #54
64+
Utf8 "Lookup"; // #55
65+
} // Constant Pool
66+
67+
0x0030; // access
68+
#8;// this_cpx
69+
#2;// super_cpx
70+
71+
[] { // Interfaces
72+
} // Interfaces
73+
74+
[] { // Fields
75+
{ // field
76+
0x0012; // access
77+
#11; // name_index
78+
#12; // descriptor_index
79+
[] { // Attributes
80+
Attr(#25) { // Signature
81+
#26;
82+
} // end Signature
83+
} // Attributes
84+
}
85+
} // Fields
86+
87+
[] { // Methods
88+
{ // method
89+
0x0000; // access
90+
#5; // name_index
91+
#27; // descriptor_index
92+
[] { // Attributes
93+
Attr(#28) { // Code
94+
2; // max_stack
95+
2; // max_locals
96+
Bytes[]{
97+
0x2AB700012A2BB500;
98+
0x07B1;
99+
}
100+
[] { // Traps
101+
} // end Traps
102+
[] { // Attributes
103+
Attr(#29) { // LineNumberTable
104+
[] { // line_number_table
105+
0 4;
106+
}
107+
} // end LineNumberTable
108+
} // Attributes
109+
} // end Code
110+
;
111+
Attr(#30) { // MethodParameters
112+
[]b { // MethodParameters
113+
#11 0x0000; // the parameter is not mandated, flag should be 0x8000 for it to be mandated
114+
}
115+
} // end MethodParameters
116+
;
117+
Attr(#25) { // Signature
118+
#31;
119+
} // end Signature
120+
} // Attributes
121+
}
122+
;
123+
{ // method
124+
0x0011; // access
125+
#15; // name_index
126+
#32; // descriptor_index
127+
[] { // Attributes
128+
Attr(#28) { // Code
129+
1; // max_stack
130+
1; // max_locals
131+
Bytes[]{
132+
0x2ABA000D0000B0;
133+
}
134+
[] { // Traps
135+
} // end Traps
136+
[] { // Attributes
137+
Attr(#29) { // LineNumberTable
138+
[] { // line_number_table
139+
0 3;
140+
}
141+
} // end LineNumberTable
142+
} // Attributes
143+
} // end Code
144+
} // Attributes
145+
}
146+
;
147+
{ // method
148+
0x0011; // access
149+
#19; // name_index
150+
#33; // descriptor_index
151+
[] { // Attributes
152+
Attr(#28) { // Code
153+
1; // max_stack
154+
1; // max_locals
155+
Bytes[]{
156+
0x2ABA00110000AC;
157+
}
158+
[] { // Traps
159+
} // end Traps
160+
[] { // Attributes
161+
Attr(#29) { // LineNumberTable
162+
[] { // line_number_table
163+
0 3;
164+
}
165+
} // end LineNumberTable
166+
} // Attributes
167+
} // end Code
168+
} // Attributes
169+
}
170+
;
171+
{ // method
172+
0x0011; // access
173+
#23; // name_index
174+
#34; // descriptor_index
175+
[] { // Attributes
176+
Attr(#28) { // Code
177+
2; // max_stack
178+
2; // max_locals
179+
Bytes[]{
180+
0x2A2BBA00150000AC;
181+
}
182+
[] { // Traps
183+
} // end Traps
184+
[] { // Attributes
185+
Attr(#29) { // LineNumberTable
186+
[] { // line_number_table
187+
0 3;
188+
}
189+
} // end LineNumberTable
190+
} // Attributes
191+
} // end Code
192+
} // Attributes
193+
}
194+
;
195+
{ // method
196+
0x0001; // access
197+
#11; // name_index
198+
#35; // descriptor_index
199+
[] { // Attributes
200+
Attr(#28) { // Code
201+
1; // max_stack
202+
1; // max_locals
203+
Bytes[]{
204+
0x2AB40007B0;
205+
}
206+
[] { // Traps
207+
} // end Traps
208+
[] { // Attributes
209+
Attr(#29) { // LineNumberTable
210+
[] { // line_number_table
211+
0 3;
212+
}
213+
} // end LineNumberTable
214+
} // Attributes
215+
} // end Code
216+
;
217+
Attr(#25) { // Signature
218+
#36;
219+
} // end Signature
220+
} // Attributes
221+
}
222+
} // Methods
223+
224+
[] { // Attributes
225+
Attr(#37) { // SourceFile
226+
#38;
227+
} // end SourceFile
228+
;
229+
Attr(#39) { // Record
230+
[] { // components
231+
{ // component
232+
#11; // name_index
233+
#12; // descriptor_index
234+
[] { // Attributes
235+
Attr(#25) { // Signature
236+
#26;
237+
} // end Signature
238+
} // Attributes
239+
}
240+
}
241+
} // end Record
242+
;
243+
Attr(#40) { // BootstrapMethods
244+
[] { // bootstrap_methods
245+
{ // bootstrap_method
246+
#41; // bootstrap_method_ref
247+
[] { // bootstrap_arguments
248+
#8;
249+
#48;
250+
#49;
251+
} // bootstrap_arguments
252+
} // bootstrap_method
253+
}
254+
} // end BootstrapMethods
255+
;
256+
Attr(#50) { // InnerClasses
257+
[] { // classes
258+
#51 #53 #55 25;
259+
}
260+
} // end InnerClasses
261+
} // Attributes
262+
} // end class R10

‎test/jdk/java/lang/reflect/records/RecordReflectionTest.java

+76-5
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (c) 2019, 2022, Oracle and/or its affiliates. All rights reserved.
2+
* Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
33
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
44
*
55
* This code is free software; you can redistribute it and/or modify it
@@ -23,8 +23,9 @@
2323

2424
/*
2525
* @test
26-
* @bug 8235369 8235550 8247444
26+
* @bug 8235369 8235550 8247444 8320575
2727
* @summary reflection test for records
28+
* @build R10
2829
* @compile RecordReflectionTest.java
2930
* @run testng/othervm RecordReflectionTest
3031
* @run testng/othervm/java.security.policy=allPermissions.policy RecordReflectionTest
@@ -57,6 +58,27 @@ record R7(String s1, String s2, String... args) {}
5758

5859
record R8<A, B>(A a, B b) implements java.io.Serializable { }
5960

61+
record R9(List<String> ls) {
62+
R9 {} // compact constructor, will contain a mandated parameter
63+
}
64+
65+
/* record R10 is defined in an accompaning jcod file, defined as:
66+
record R10(List<String> ls) { // in this case there wasn't be any compact constructor and thus no mandated param
67+
}
68+
*/
69+
70+
record R11(int i, List<String> ls) {
71+
R11 {} // compact constructor, will contain mandated parameters
72+
}
73+
74+
record R12(List<String> ls, int i) {
75+
R12 {} // compact constructor, will contain mandated parameters
76+
}
77+
78+
record R13(List<String> ls1, int i, List<String> ls2) {
79+
R13 {} // compact constructor, will contain mandated parameters
80+
}
81+
6082
@DataProvider(name = "recordClasses")
6183
public Object[][] recordClassData() {
6284
return List.of(R1.class,
@@ -66,8 +88,13 @@ public Object[][] recordClassData() {
6688
R5.class,
6789
R6.class,
6890
R7.class,
69-
R8.class)
70-
.stream().map(c -> new Object[] {c}).toArray(Object[][]::new);
91+
R8.class,
92+
R9.class,
93+
R10.class,
94+
R11.class,
95+
R12.class,
96+
R13.class
97+
).stream().map(c -> new Object[] {c}).toArray(Object[][]::new);
7198
}
7299

73100
@Test(dataProvider = "recordClasses")
@@ -124,6 +151,34 @@ public Object[][] reflectionData() {
124151
new Object[]{ new R1(), new R2(6, 7), new R3(List.of("s")) },
125152
new String[]{ "r1", "r2", "r3" },
126153
new String[]{ R1.class.toString(), R2.class.toString(), R3.class.toString()} },
154+
new Object[] { new R9(List.of("1")),
155+
1,
156+
new Object[]{ List.of("1") },
157+
new String[]{ "ls" },
158+
new String[]{ "java.util.List<java.lang.String>"} },
159+
/* R10 has exactly the same definition as R9 but the parameter of the compact constructor doesn't have
160+
* the mandated flag, nevertheless we should be able to load the same generic information
161+
*/
162+
new Object[] { new R10(List.of("1")),
163+
1,
164+
new Object[]{ List.of("1") },
165+
new String[]{ "ls" },
166+
new String[]{ "java.util.List<java.lang.String>"} },
167+
new Object[] { new R11(1, List.of("1")),
168+
2,
169+
new Object[]{ 1, List.of("1") },
170+
new String[]{ "i", "ls" },
171+
new String[]{ "int", "java.util.List<java.lang.String>"} },
172+
new Object[] { new R12(List.of("1"), 1),
173+
2,
174+
new Object[]{ List.of("1"), 1 },
175+
new String[]{ "ls", "i" },
176+
new String[]{ "java.util.List<java.lang.String>", "int"} },
177+
new Object[] { new R13(List.of("1"), 1, List.of("2")),
178+
3,
179+
new Object[]{ List.of("1"), 1, List.of("2") },
180+
new String[]{ "ls1", "i", "ls2" },
181+
new String[]{ "java.util.List<java.lang.String>", "int", "java.util.List<java.lang.String>"} },
127182
};
128183
}
129184

@@ -149,6 +204,23 @@ public void testRecordReflection(Object recordOb,
149204
rc.getAccessor().getGenericReturnType(), signatures[i]));
150205
i++;
151206
}
207+
// now let's check constructors
208+
var constructor = recordClass.getDeclaredConstructors()[0];
209+
i = 0;
210+
for (var p: constructor.getParameters()) {
211+
assertEquals(p.getParameterizedType().toString(), signatures[i],
212+
String.format("signature of method \"%s\" different from expected signature \"%s\"",
213+
p.getType().toString(), signatures[i]));
214+
i++;
215+
}
216+
// similar as above but testing another API
217+
i = 0;
218+
for (var p : constructor.getGenericParameterTypes()) {
219+
assertEquals(p.toString(), signatures[i],
220+
String.format("signature of method \"%s\" different from expected signature \"%s\"",
221+
p.toString(), signatures[i]));
222+
i++;
223+
}
152224
}
153225

154226
@Retention(RetentionPolicy.RUNTIME)
@@ -201,5 +273,4 @@ public void testReadOnlyFieldInRecord() throws Throwable {
201273
} catch (IllegalAccessException e) {
202274
}
203275
}
204-
205276
}

1 commit comments

Comments
 (1)

openjdk-notifier[bot] commented on May 24, 2024

@openjdk-notifier[bot]
openjdk-notifier[bot]
on May 24, 2024

Review

Issues

Please sign in to comment.