8000 Add cached Sets to ImmutableModifierSet · sakerbuild/saker.java.compiler@545c95b · GitHub
[go: up one dir, main page]
Skip to content

Commit 545c95b

Browse files
SipkabSipkab
committed
Add cached Sets to ImmutableModifierSet
1 parent 312ae86 commit 545c95b

File tree

2 files changed

+224
-18
lines changed

2 files changed

+224
-18
lines changed

‎impl-util-jdk8/src/main/saker/java/compiler/util8/impl/parser/signature/CompilationUnitSignatureParser8.java

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -531,7 +531,7 @@ public Signature visitVariable(VariableTree tree, ParseContext context) {
531531
switch (context.getDeclaringKindIndex()) {
532532
case ElementKindCompatUtils.ELEMENTKIND_INDEX_ANNOTATION_TYPE:
533533
case ElementKindCompatUtils.ELEMENTKIND_INDEX_INTERFACE: {
534-
varmodifierflagss = varmodifierflagss.added(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL);
534+
varmodifierflagss = varmodifierflagss.added(ImmutableModifierSet.INSTANCE_PUBLIC_STATIC_FINAL);
535535
break;
536536
}
537537
default: {

‎impl/src/main/saker/java/compiler/impl/util/ImmutableModifierSet.java

Lines changed: 223 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -37,8 +37,6 @@
3737
import testing.saker.java.compiler.TestFlag;
3838

3939
public final class ImmutableModifierSet extends AbstractSet<Modifier> {
40-
private static final ImmutableModifierSet EMPTY_INSTANCE = new ImmutableModifierSet((short) 0);
41-
4240
//define our own modifier values array, as newer JDKs can add new values, which can distrupt order or ordinal values
4341
//if new values are introduced, export this array to a JDK version dependent bundle. only appending to it
4442
// THE ORDER IN THIS ARRAY IS NOT TO BE MODIFIED FOR SERIALIZATION COMPATIBILITY
@@ -65,8 +63,10 @@ public final class ImmutableModifierSet extends AbstractSet<Modifier> {
6563
private static final int[] ENUM_ORDINAL_INDEX_LOOKUP;
6664

6765
private static final int INDEX_SEALED = 12;
66+
private static final int INDEX_NON_SEALED = 13;
6867

6968
public static final Modifier MODIFIER_SEALED;
69+
public static final Modifier MODIFIER_NON_SEALED;
7070

7171
private static final short ALL_RECOGNIZED_FLAGS_MASK;
7272
static {
@@ -97,18 +97,119 @@ public final class ImmutableModifierSet extends AbstractSet<Modifier> {
9797
}
9898
ALL_RECOGNIZED_FLAGS_MASK = allrecognized;
9999
MODIFIER_SEALED = ENUM_VALUES[INDEX_SEALED];
100+
MODIFIER_NON_SEALED = ENUM_VALUES[INDEX_NON_SEALED];
100101
}
101102

102103
public static final short FLAG_NONE = 0;
103104
public static final short FLAG_PUBLIC = 1 << 0;
104105
public static final short FLAG_PROTECTED = 1 << 1;
105106
public static final short FLAG_PRIVATE = 1 << 2;
107+
public static final short FLAG_ABSTRACT = 1 << 3;
108+
public static final short FLAG_DEFAULT = 1 << 4;
109+
public static final short FLAG_STATIC = 1 << 5;
110+
public static final short FLAG_FINAL = 1 << 6;
111+
public static final short FLAG_TRANSIENT = 1 << 7;
112+
public static final short FLAG_VOLATILE = 1 << 8;
113+
public static final short FLAG_SYNCHRONIZED = 1 << 9;
114+
public static final short FLAG_NATIVE = 1 << 10;
115+
public static final short FLAG_STRICTFP = 1 << 11;
116+
public static final short FLAG_SEALED = 1 << 12;
117+
public static final short FLAG_NON_SEALED = 1 << 13;
118+
119+
public static final ImmutableModifierSet INSTANCE_NONE = new ImmutableModifierSet(FLAG_NONE);
120+
public static final ImmutableModifierSet INSTANCE_PUBLIC = new ImmutableModifierSet(FLAG_PUBLIC);
121+
public static final ImmutableModifierSet INSTANCE_PROTECTED = new ImmutableModifierSet(FLAG_PROTECTED);
122+
public static final ImmutableModifierSet INSTANCE_PRIVATE = new ImmutableModifierSet(FLAG_PRIVATE);
123+
public static final ImmutableModifierSet INSTANCE_ABSTRACT = new ImmutableModifierSet(FLAG_ABSTRACT);
124+
public static final ImmutableModifierSet INSTANCE_DEFAULT = new ImmutableModifierSet(FLAG_DEFAULT);
125+
public static final ImmutableModifierSet INSTANCE_STATIC = new ImmutableModifierSet(FLAG_STATIC);
126+
public static final ImmutableModifierSet INSTANCE_FINAL = new ImmutableModifierSet(FLAG_FINAL);
127+
public static final ImmutableModifierSet INSTANCE_TRANSIENT = new ImmutableModifierSet(FLAG_TRANSIENT);
128+
public static final ImmutableModifierSet INSTANCE_VOLATILE = new ImmutableModifierSet(FLAG_VOLATILE);
129+
public static final ImmutableModifierSet INSTANCE_SYNCHRONIZED = new ImmutableModifierSet(FLAG_SYNCHRONIZED);
130+
public static final ImmutableModifierSet INSTANCE_NATIVE = new ImmutableModifierSet(FLAG_NATIVE);
131+
public static final ImmutableModifierSet INSTANCE_STRICTFP = new ImmutableModifierSet(FLAG_STRICTFP);
132+
public static final ImmutableModifierSet INSTANCE_SEALED = new ImmutableModifierSet(FLAG_SEALED);
133+
public static final ImmutableModifierSet INSTANCE_NON_SEALED = new ImmutableModifierSet(FLAG_NON_SEALED);
134+
135+
public static final ImmutableModifierSet INSTANCE_PUBLIC_STATIC = new ImmutableModifierSet(
136+
(short) (FLAG_PUBLIC | FLAG_STATIC));
137+
public static final ImmutableModifierSet INSTANCE_PROTECTED_STATIC = new ImmutableModifierSet(
138+
(short) (FLAG_PROTECTED | FLAG_STATIC));
139+
public static final ImmutableModifierSet INSTANCE_PRIVATE_STATIC = new ImmutableModifierSet(
140+
(short) (FLAG_PRIVATE | FLAG_STATIC));
141+
142+
public static final ImmutableModifierSet INSTANCE_STATIC_FINAL = new ImmutableModifierSet(
143+
(short) (FLAG_STATIC | FLAG_FINAL));
144+
public static final ImmutableModifierSet INSTANCE_PUBLIC_STATIC_FINAL = new ImmutableModifierSet(
145+
(short) (FLAG_PUBLIC | FLAG_STATIC | FLAG_FINAL));
146+
public static final ImmutableModifierSet INSTANCE_PROTECTED_STATIC_FINAL = new ImmutableModifierSet(
147+
(short) (FLAG_PROTECTED | FLAG_STATIC | FLAG_FINAL));
148+
public static final ImmutableModifierSet INSTANCE_PRIVATE_STATIC_FINAL = new ImmutableModifierSet(
149+
(short) (FLAG_PRIVATE | FLAG_STATIC | FLAG_FINAL));
150+
151+
public static final ImmutableModifierSet INSTANCE_PUBLIC_ABSTRACT = new ImmutableModifierSet(
152+
(short) (FLAG_PUBLIC | FLAG_ABSTRACT));
153+
public static final ImmutableModifierSet INSTANCE_PROTECTED_ABSTRACT = new ImmutableModifierSet(
154+
(short) (FLAG_PROTECTED | FLAG_ABSTRACT));
155+
public static final ImmutableModifierSet INSTANCE_PRIVATE_ABSTRACT = new ImmutableModifierSet(
156+
(short) (FLAG_PRIVATE | FLAG_ABSTRACT));
157+
158+
public static final ImmutableModifierSet INSTANCE_PUBLIC_VOLATILE = new ImmutableModifierSet(
159+
(short) (FLAG_PUBLIC | FLAG_VOLATILE));
160+
public static final ImmutableModifierSet INSTANCE_PROTECTED_VOLATILE = new ImmutableModifierSet(
161+
(short) (FLAG_PROTECTED | FLAG_VOLATILE));
162+
public static final ImmutableModifierSet INSTANCE_PRIVATE_VOLATILE = new ImmutableModifierSet(
163+
(short) (FLAG_PRIVATE | FLAG_VOLATILE));
164+
165+
public static final ImmutableModifierSet INSTANCE_PUBLIC_SYNCHRONIZED = new ImmutableModifierSet(
166+
(short) (FLAG_PUBLIC | FLAG_SYNCHRONIZED));
167+
public static final ImmutableModifierSet INSTANCE_PROTECTED_SYNCHRONIZED = new ImmutableModifierSet(
168+
(short) (FLAG_PROTECTED | FLAG_SYNCHRONIZED));
169+
public static final ImmutableModifierSet INSTANCE_PRIVATE_SYNCHRONIZED = new ImmutableModifierSet(
170+
(short) (FLAG_PRIVATE | FLAG_SYNCHRONIZED));
171+
172+
public static final ImmutableModifierSet INSTANCE_SYNCHRONIZED_FINAL = new ImmutableModifierSet(
173+
(short) (FLAG_SYNCHRONIZED | FLAG_FINAL));
174+
public static final ImmutableModifierSet INSTANCE_PUBLIC_SYNCHRONIZED_FINAL = new ImmutableModifierSet(
175+
(short) (FLAG_PUBLIC | FLAG_SYNCHRONIZED | FLAG_FINAL));
176+
public static final ImmutableModifierSet INSTANCE_PROTECTED_SYNCHRONIZED_FINAL = new ImmutableModifierSet(
177+
(short) (FLAG_PROTECTED | FLAG_SYNCHRONIZED | FLAG_FINAL));
178+
public static final ImmutableModifierSet INSTANCE_PRIVATE_SYNCHRONIZED_FINAL = new ImmutableModifierSet(
179+
(short) (FLAG_PRIVATE | FLAG_SYNCHRONIZED | FLAG_FINAL));
180+
181+
public static final ImmutableModifierSet INSTANCE_PUBLIC_NATIVE = new ImmutableModifierSet(
182+
(short) (FLAG_PUBLIC | FLAG_NATIVE));
183+
public static final ImmutableModifierSet INSTANCE_PROTECTED_NATIVE = new ImmutableModifierSet(
184+
(short) (FLAG_PROTECTED | FLAG_NATIVE));
185+
public static final ImmutableModifierSet INSTANCE_PRIVATE_NATIVE = new ImmutableModifierSet(
186+
(short) (FLAG_PRIVATE | FLAG_NATIVE));
187+
188+
public static final ImmutableModifierSet INSTANCE_TRANSIENT_VOLATILE = new ImmutableModifierSet(
189+
(short) (FLAG_TRANSIENT | FLAG_VOLATILE));
190+
public static final ImmutableModifierSet INSTANCE_PUBLIC_TRANSIENT_VOLATILE = new ImmutableModifierSet(
191+
(short) (FLAG_PUBLIC | FLAG_TRANSIENT | FLAG_VOLATILE));
192+
public static final ImmutableModifierSet INSTANCE_PROTECTED_TRANSIENT_VOLATILE = new ImmutableModifierSet(
193+
(short) (FLAG_PROTECTED | FLAG_TRANSIENT | FLAG_VOLATILE));
194+
public static final ImmutableModifierSet INSTANCE_PRIVATE_TRANSIENT_VOLATILE = new ImmutableModifierSet(
195+
(short) (FLAG_PRIVATE | FLAG_TRANSIENT | FLAG_VOLATILE));
106196

107197
static {
108198
if (TestFlag.ENABLED) {
109199
if (FLAG_PUBLIC != getFlag(EnumSet.of(Modifier.PUBLIC))
110200
|| FLAG_PROTECTED != getFlag(EnumSet.of(Modifier.PROTECTED))
111-
|| FLAG_PRIVATE != getFlag(EnumSet.of(Modifier.PRIVATE))) {
201+
|| FLAG_PRIVATE != getFlag(EnumSet.of(Modifier.PRIVATE))
202+
|| FLAG_ABSTRACT != getFlag(EnumSet.of(Modifier.ABSTRACT))
203+
|| FLAG_DEFAULT != getFlag(EnumSet.of(Modifier.DEFAULT))
204+
|| FLAG_STATIC != getFlag(EnumSet.of(Modifier.STATIC))
205+
|| FLAG_FINAL != getFlag(EnumSet.of(Modifier.FINAL))
206+
|| FLAG_TRANSIENT != getFlag(EnumSet.of(Modifier.TRANSIENT))
207+
|| FLAG_VOLATILE != getFlag(EnumSet.of(Modifier.VOLATILE))
208+
|| FLAG_SYNCHRONIZED != getFlag(EnumSet.of(Modifier.SYNCHRONIZED))
209+
|| FLAG_NATIVE != getFlag(EnumSet.of(Modifier.NATIVE))
210+
|| FLAG_STRICTFP != getFlag(EnumSet.of(Modifier.STRICTFP))
211+
|| (MODIFIER_SEALED != null && FLAG_SEALED != getFlag(EnumSet.of(MODIFIER_SEALED)))
212+
|| (MODIFIER_NON_SEALED != null && FLAG_NON_SEALED != getFlag(EnumSet.of(MODIFIER_NON_SEALED)))) {
112213
//sanity checks that the compile time constants equal the converted ones
113214
throw new AssertionError("Flag value mismatch.");
114215
}
@@ -122,7 +223,7 @@ private ImmutableModifierSet(short flags) {
122223
}
123224

124225
public static ImmutableModifierSet empty() {
125-
return EMPTY_INSTANCE;
226+
return INSTANCE_NONE;
126227
}
127228

128229
public static ImmutableModifierSet get(Set<Modifier> modifiers) {
@@ -133,16 +234,13 @@ public static ImmutableModifierSet get(Set<Modifier> modifiers) {
133234
return (ImmutableModifierSet) modifiers;
134235
}
135236
short f = getFlag(modifiers);
136-
if (f == 0) {
137-
return EMPTY_INSTANCE;
138-
}
139-
return new ImmutableModifierSet(f);
237+
return getSetOfFlags(f);
140238
}
141239

142240
public static ImmutableModifierSet of(Modifier... modifiers) {
143241
Objects.requireNonNull(modifiers, "modifiers");
144242
if (modifiers.length == 0) {
145-
return EMPTY_INSTANCE;
243+
return INSTANCE_NONE;
146244
}
147245
short f = 0;
148246
for (Modifier m : modifiers) {
@@ -153,7 +251,7 @@ public static ImmutableModifierSet of(Modifier... modifiers) {
153251
}
154252
f |= 1 << ordinal;
155253
}
156-
return new ImmutableModifierSet(f);
254+
return getSetOfFlags(f);
157255
}
158256

159257
public static short getFlag(Set<Modifier> modifiers) {
@@ -175,7 +273,107 @@ public static short getFlag(Set<Modifier> modifiers) {
175273

176274
public static ImmutableModifierSet forFlags(short flags) {
177275
checkFlagsSupport(flags);
178-
return new ImmutableModifierSet(flags);
276+
return getSetOfFlags(flags);
277+
}
278+
279+
private static ImmutableModifierSet getSetOfFlags(short flags) {
280+
//cache commonly occurring modifier instances so their retrieval doesn't create new set objects
281+
switch (flags) {
282+
case FLAG_NONE:
283+
return INSTANCE_NONE;
284+
case FLAG_PUBLIC:
285+
return INSTANCE_PUBLIC;
286+
case FLAG_PROTECTED:
287+
return INSTANCE_PROTECTED;
288+
case FLAG_PRIVATE:
289+
return INSTANCE_PRIVATE;
290+
case FLAG_ABSTRACT:
291+
return INSTANCE_ABSTRACT;
292+
case FLAG_DEFAULT:
293+
return INSTANCE_DEFAULT;
294+
case FLAG_STATIC:
295+
return INSTANCE_STATIC;
296+
case FLAG_FINAL:
297+
return INSTANCE_FINAL;
298+
case FLAG_TRANSIENT:
299+
return INSTANCE_TRANSIENT;
300+
case FLAG_VOLATILE:
301+
return INSTANCE_VOLATILE;
302+
case FLAG_SYNCHRONIZED:
303+
return INSTANCE_SYNCHRONIZED;
304+
case FLAG_NATIVE:
305+
return INSTANCE_NATIVE;
306+
case FLAG_STRICTFP:
307+
return INSTANCE_STRICTFP;
308+
case FLAG_SEALED:
309+
return INSTANCE_SEALED;
310+
case FLAG_NON_SEALED:
311+
return INSTANCE_NON_SEALED;
312+
313+
case FLAG_PUBLIC | FLAG_STATIC:
314+
return INSTANCE_PUBLIC_STATIC;
315+
case FLAG_PROTECTED | FLAG_STATIC:
316+
return INSTANCE_PROTECTED_STATIC;
317+
case FLAG_PRIVATE | FLAG_STATIC:
318+
return INSTANCE_PRIVATE_STATIC;
319+
320+
case FLAG_STATIC | FLAG_FINAL:
321+
return INSTANCE_STATIC_FINAL;
322+
case FLAG_PUBLIC | FLAG_STATIC | FLAG_FINAL:
323+
return INSTANCE_PUBLIC_STATIC_FINAL;
324+
case FLAG_PROTECTED | FLAG_STATIC | FLAG_FINAL:
325+
return INSTANCE_PROTECTED_STATIC_FINAL;
326+
case FLAG_PRIVATE | FLAG_STATIC | FLAG_FINAL:
327+
return INSTANCE_PRIVATE_STATIC_FINAL;
328+
329+
case FLAG_PUBLIC | FLAG_ABSTRACT:
330+
return INSTANCE_PUBLIC_ABSTRACT;
331+
case FLAG_PROTECTED | FLAG_ABSTRACT:
332+
return INSTANCE_PROTECTED_ABSTRACT;
333+
case FLAG_PRIVATE | FLAG_ABSTRACT:
334+
return INSTANCE_PRIVATE_ABSTRACT;
335+
336+
case FLAG_PUBLIC | FLAG_VOLATILE:
337+
return INSTANCE_PUBLIC_VOLATILE;
338+
case FLAG_PROTECTED | FLAG_VOLATILE:
339+
return INSTANCE_PROTECTED_VOLATILE;
340+
case FLAG_PRIVATE | FLAG_VOLATILE:
341+
return INSTANCE_PRIVATE_VOLATILE;
342+
343+
case FLAG_PUBLIC | FLAG_SYNCHRONIZED:
344+
return INSTANCE_PUBLIC_SYNCHRONIZED;
345+
case FLAG_PROTECTED | FLAG_SYNCHRONIZED:
346+
return INSTANCE_PROTECTED_SYNCHRONIZED;
347+
case FLAG_PRIVATE | FLAG_SYNCHRONIZED:
348+
return INSTANCE_PRIVATE_SYNCHRONIZED;
349+
350+
case FLAG_SYNCHRONIZED | FLAG_FINAL:
351+
return INSTANCE_SYNCHRONIZED_FINAL;
352+
case FLAG_PUBLIC | FLAG_SYNCHRONIZED | FLAG_FINAL:
353+
return INSTANCE_PUBLIC_SYNCHRONIZED_FINAL;
354+
case FLAG_PROTECTED | FLAG_SYNCHRONIZED | FLAG_FINAL:
355+
return INSTANCE_PROTECTED_SYNCHRONIZED_FINAL;
356+
case FLAG_PRIVATE | FLAG_SYNCHRONIZED | FLAG_FINAL:
357+
return INSTANCE_PRIVATE_SYNCHRONIZED_FINAL;
358+
359+
case FLAG_PUBLIC | FLAG_NATIVE:
360+
return INSTANCE_PUBLIC_NATIVE;
361+
case FLAG_PROTECTED | FLAG_NATIVE:
362+
return INSTANCE_PROTECTED_NATIVE;
363+
case FLAG_PRIVATE | FLAG_NATIVE:
364+
return INSTANCE_PRIVATE_NATIVE;
365+
366+
case FLAG_TRANSIENT | FLAG_VOLATILE:
367+
return INSTANCE_TRANSIENT_VOLATILE;
368+
case FLAG_PUBLIC | FLAG_TRANSIENT | FLAG_VOLATILE:
369+
return INSTANCE_PUBLIC_TRANSIENT_VOLATILE;
370+
case FLAG_PROTECTED | FLAG_TRANSIENT | FLAG_VOLATILE:
371+
return INSTANCE_PROTECTED_TRANSIENT_VOLATILE;
372+
case FLAG_PRIVATE | FLAG_TRANSIENT | FLAG_VOLATILE:
373+
return INSTANCE_PRIVATE_TRANSIENT_VOLATILE;
374+
default:
375+
return new ImmutableModifierSet(flags);
376+
}
179377
}
180378

181379
public static void writeExternalFlag(DataOutput out, short flags) throws IOException {
@@ -218,7 +416,7 @@ public static boolean isExternalObjectFlag(Object o) {
218416
public static ImmutableModifierSet readExternalFlagSet(DataInput in) throws IOException {
219417
short flags = in.readShort();
220418
checkFlagsSupport(flags);
221-
return new ImmutableModifierSet(flags);
419+
return getSetOfFlags(flags);
222420
}
223421

224422
private static void checkFlagsSupport(short flags) {
@@ -245,17 +443,25 @@ public ImmutableModifierSet added(Modifier modifier) {
245443
if (nf == this.flags) {
246444
return this;
247445
}
248-
return new ImmutableModifierSet(nf);
446+
return getSetOfFlags(nf);
249447
}
250448

251449
public ImmutableModifierSet added(Set<Modifier> modifiers) {
252450
Objects.requireNonNull(modifiers, "modifiers");
253-
short nf = getFlag(modifiers);
254-
nf |= this.flags;
451+
short nf = (short) (this.flags | getFlag(modifiers));
452+
if (nf == this.flags) {
453+
return this;
454+
}
455+
return getSetOfFlags(nf);
456+
}
457+
458+
public ImmutableModifierSet added(ImmutableModifierSet modifiers) {
459+
Objects.requireNonNull(modifiers, "modifiers");
460+
short nf = (short) (this.flags | modifiers.flags);
255461
if (nf == this.flags) {
256462
return this;
257463
}
258-
return new ImmutableModifierSet(nf);
464+
return getSetOfFlags(nf);
259465
}
260466

261467
public ImmutableModifierSet added(Modifier... modifiers) {
@@ -273,7 +479,7 @@ public ImmutableModifierSet added(Modifier... modifiers) {
273479
if (nf == this.flags) {
274480
return this;
275481
}
276-
return new ImmutableModifierSet(nf);
482+
return getSetOfFlags(nf);
277483
}
278484

279485
@Override

0 commit comments

Comments
 (0)
0