1 /*
2 * Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package jdk.internal.classfile.impl;
26
27 import java.lang.classfile.*;
28 import java.lang.classfile.attribute.*;
29 import java.lang.classfile.constantpool.ClassEntry;
30 import java.lang.classfile.constantpool.ConstantValueEntry;
31 import java.lang.classfile.constantpool.ModuleEntry;
32 import java.lang.classfile.constantpool.NameAndTypeEntry;
33 import java.lang.classfile.constantpool.PackageEntry;
34 import java.lang.classfile.constantpool.Utf8Entry;
35 import java.util.Collection;
36 import java.util.List;
37 import java.util.Optional;
38
39 import jdk.internal.access.SharedSecrets;
40
41 import static java.util.Objects.requireNonNull;
42
43 public abstract sealed class UnboundAttribute<T extends Attribute<T>>
44 extends AbstractElement
45 implements Attribute<T>, Util.Writable {
46 protected final AttributeMapper<T> mapper;
47
48 public UnboundAttribute(AttributeMapper<T> mapper) {
49 this.mapper = mapper;
50 }
51
52 @Override
53 public AttributeMapper<T> attributeMapper() {
54 return mapper;
55 }
56
57 @Override
58 public String attributeName() {
59 return mapper.name();
60 }
61
62 @Override
63 @SuppressWarnings("unchecked")
64 public void writeTo(BufWriterImpl buf) {
65 mapper.writeAttribute(buf, (T) this);
66 }
67
68 @Override
69 public void writeTo(DirectClassBuilder builder) {
70 builder.writeAttribute(this);
71 }
72
73 @Override
74 public void writeTo(DirectCodeBuilder builder) {
75 builder.writeAttribute(this);
76 }
77
78 @Override
79 public void writeTo(DirectMethodBuilder builder) {
80 builder.writeAttribute(this);
81 }
82
83 @Override
84 public void writeTo(DirectFieldBuilder builder) {
85 builder.writeAttribute(this);
86 }
87
88 @Override
89 public String toString() {
90 return String.format("Attribute[name=%s]", mapper.name());
91 }
92 public static final class UnboundConstantValueAttribute
93 extends UnboundAttribute<ConstantValueAttribute>
94 implements ConstantValueAttribute {
95
96 private final ConstantValueEntry entry;
97
98 public UnboundConstantValueAttribute(ConstantValueEntry entry) {
99 super(Attributes.constantValue());
100 this.entry = requireNonNull(entry);
101 }
102
103 @Override
104 public ConstantValueEntry constant() {
105 return entry;
106 }
107
108 }
109
110 public static final class UnboundDeprecatedAttribute
111 extends UnboundAttribute<DeprecatedAttribute>
112 implements DeprecatedAttribute {
113 public UnboundDeprecatedAttribute() {
114 super(Attributes.deprecated());
115 }
116 }
117
118 public static final class UnboundSyntheticAttribute
119 extends UnboundAttribute<SyntheticAttribute>
120 implements SyntheticAttribute {
121 public UnboundSyntheticAttribute() {
122 super(Attributes.synthetic());
123 }
124 }
125
126 public static final class UnboundSignatureAttribute
127 extends UnboundAttribute<SignatureAttribute>
128 implements SignatureAttribute {
129 private final Utf8Entry signature;
130
131 public UnboundSignatureAttribute(Utf8Entry signature) {
132 super(Attributes.signature());
133 this.signature = requireNonNull(signature);
134 }
135
136 @Override
137 public Utf8Entry signature() {
138 return signature;
139 }
140 }
141
142 public static final class UnboundExceptionsAttribute
143 extends UnboundAttribute<ExceptionsAttribute>
144 implements ExceptionsAttribute {
145 private final List<ClassEntry> exceptions;
146
147 public UnboundExceptionsAttribute(List<ClassEntry> exceptions) {
148 super(Attributes.exceptions());
149 this.exceptions = List.copyOf(exceptions);
150 }
151
152 @Override
153 public List<ClassEntry> exceptions() {
154 return exceptions;
155 }
156 }
157
158 public static final class UnboundAnnotationDefaultAttribute
159 extends UnboundAttribute<AnnotationDefaultAttribute>
160 implements AnnotationDefaultAttribute {
161 private final AnnotationValue annotationDefault;
162
163 public UnboundAnnotationDefaultAttribute(AnnotationValue annotationDefault) {
164 super(Attributes.annotationDefault());
165 this.annotationDefault = requireNonNull(annotationDefault);
166 }
167
168 @Override
169 public AnnotationValue defaultValue() {
170 return annotationDefault;
171 }
172 }
173
174 public static final class UnboundSourceFileAttribute extends UnboundAttribute<SourceFileAttribute>
175 implements SourceFileAttribute {
176 private final Utf8Entry sourceFile;
177
178 public UnboundSourceFileAttribute(Utf8Entry sourceFile) {
179 super(Attributes.sourceFile());
180 this.sourceFile = requireNonNull(sourceFile);
181 }
182
183 @Override
184 public Utf8Entry sourceFile() {
185 return sourceFile;
186 }
187
188 }
189
190 public static final class UnboundStackMapTableAttribute extends UnboundAttribute<StackMapTableAttribute>
191 implements StackMapTableAttribute {
192 private final List<StackMapFrameInfo> entries;
193
194 public UnboundStackMapTableAttribute(List<StackMapFrameInfo> entries) {
195 super(Attributes.stackMapTable());
196 this.entries = List.copyOf(entries);
197 }
198
199 @Override
200 public List<StackMapFrameInfo> entries() {
201 return entries;
202 }
203 }
204
205 public static final class UnboundInnerClassesAttribute
206 extends UnboundAttribute<InnerClassesAttribute>
207 implements InnerClassesAttribute {
208 private final List<InnerClassInfo> innerClasses;
209
210 public UnboundInnerClassesAttribute(List<InnerClassInfo> innerClasses) {
211 super(Attributes.innerClasses());
212 this.innerClasses = List.copyOf(innerClasses);
213 }
214
215 @Override
216 public List<InnerClassInfo> classes() {
217 return innerClasses;
218 }
219 }
220
221 public static final class UnboundRecordAttribute
222 extends UnboundAttribute<RecordAttribute>
223 implements RecordAttribute {
224 private final List<RecordComponentInfo> components;
225
226 public UnboundRecordAttribute(List<RecordComponentInfo> components) {
227 super(Attributes.record());
228 this.components = List.copyOf(components);
229 }
230
231 @Override
232 public List<RecordComponentInfo> components() {
233 return components;
234 }
235 }
236
237 public static final class UnboundEnclosingMethodAttribute
238 extends UnboundAttribute<EnclosingMethodAttribute>
239 implements EnclosingMethodAttribute {
240 private final ClassEntry classEntry;
241 private final NameAndTypeEntry method;
242
243 public UnboundEnclosingMethodAttribute(ClassEntry classEntry, NameAndTypeEntry method) {
244 super(Attributes.enclosingMethod());
245 this.classEntry = requireNonNull(classEntry);
246 this.method = method;
247 }
248
249 @Override
250 public ClassEntry enclosingClass() {
251 return classEntry;
252 }
253
254 @Override
255 public Optional<NameAndTypeEntry> enclosingMethod() {
256 return Optional.ofNullable(method);
257 }
258 }
259
260 public static final class UnboundMethodParametersAttribute
261 extends UnboundAttribute<MethodParametersAttribute>
262 implements MethodParametersAttribute {
263 private final List<MethodParameterInfo> parameters;
264
265 public UnboundMethodParametersAttribute(List<MethodParameterInfo> parameters) {
266 super(Attributes.methodParameters());
267 this.parameters = List.copyOf(parameters);
268 }
269
270 @Override
271 public List<MethodParameterInfo> parameters() {
272 return parameters;
273 }
274 }
275
276 public static final class UnboundModuleTargetAttribute
277 extends UnboundAttribute<ModuleTargetAttribute>
278 implements ModuleTargetAttribute {
279 final Utf8Entry moduleTarget;
280
281 public UnboundModuleTargetAttribute(Utf8Entry moduleTarget) {
282 super(Attributes.moduleTarget());
283 this.moduleTarget = requireNonNull(moduleTarget);
284 }
285
286 @Override
287 public Utf8Entry targetPlatform() {
288 return moduleTarget;
289 }
290 }
291
292 public static final class UnboundModuleMainClassAttribute
293 extends UnboundAttribute<ModuleMainClassAttribute>
294 implements ModuleMainClassAttribute {
295 final ClassEntry mainClass;
296
297 public UnboundModuleMainClassAttribute(ClassEntry mainClass) {
298 super(Attributes.moduleMainClass());
299 this.mainClass = requireNonNull(mainClass);
300 }
301
302 @Override
303 public ClassEntry mainClass() {
304 return mainClass;
305 }
306 }
307
308 public static final class UnboundModuleHashesAttribute
309 extends UnboundAttribute<ModuleHashesAttribute>
310 implements ModuleHashesAttribute {
311 private final Utf8Entry algorithm;
312 private final List<ModuleHashInfo> hashes;
313
314 public UnboundModuleHashesAttribute(Utf8Entry algorithm, List<ModuleHashInfo> hashes) {
315 super(Attributes.moduleHashes());
316 this.algorithm = requireNonNull(algorithm);
317 this.hashes = List.copyOf(hashes);
318 }
319
320 @Override
321 public Utf8Entry algorithm() {
322 return algorithm;
323 }
324
325 @Override
326 public List<ModuleHashInfo> hashes() {
327 return hashes;
328 }
329 }
330
331 public static final class UnboundModulePackagesAttribute
332 extends UnboundAttribute<ModulePackagesAttribute>
333 implements ModulePackagesAttribute {
334 private final Collection<PackageEntry> packages;
335
336 public UnboundModulePackagesAttribute(Collection<PackageEntry> packages) {
337 super(Attributes.modulePackages());
338 this.packages = List.copyOf(packages);
339 }
340
341 @Override
342 public List<PackageEntry> packages() {
343 return List.copyOf(packages);
344 }
345 }
346
347 public static final class UnboundModuleResolutionAttribute
348 extends UnboundAttribute<ModuleResolutionAttribute>
349 implements ModuleResolutionAttribute {
350 private final int resolutionFlags;
351
352 public UnboundModuleResolutionAttribute(int flags) {
353 super(Attributes.moduleResolution());
354 resolutionFlags = flags;
355 }
356
357 @Override
358 public int resolutionFlags() {
359 return resolutionFlags;
360 }
361 }
362
363 public static final class UnboundPermittedSubclassesAttribute
364 extends UnboundAttribute<PermittedSubclassesAttribute>
365 implements PermittedSubclassesAttribute {
366 private final List<ClassEntry> permittedSubclasses;
367
368 public UnboundPermittedSubclassesAttribute(List<ClassEntry> permittedSubclasses) {
369 super(Attributes.permittedSubclasses());
370 this.permittedSubclasses = List.copyOf(permittedSubclasses);
371 }
372
373 @Override
374 public List<ClassEntry> permittedSubclasses() {
375 return permittedSubclasses;
376 }
377 }
378
379 public static final class UnboundLoadableDescriptorsAttribute
380 extends UnboundAttribute<LoadableDescriptorsAttribute>
381 implements LoadableDescriptorsAttribute {
382 private final List<Utf8Entry> loadableDescriptors;
383
384 public UnboundLoadableDescriptorsAttribute(List<Utf8Entry> loadableDescriptors) {
385 super(Attributes.loadableDescriptors());
386 this.loadableDescriptors = List.copyOf(loadableDescriptors);
387 }
388
389 @Override
390 public List<Utf8Entry> loadableDescriptors() {
391 return loadableDescriptors;
392 }
393 }
394
395 public static final class UnboundNestMembersAttribute
396 extends UnboundAttribute<NestMembersAttribute>
397 implements NestMembersAttribute {
398 private final List<ClassEntry> memberEntries;
399
400 public UnboundNestMembersAttribute(List<ClassEntry> memberEntries) {
401 super(Attributes.nestMembers());
402 this.memberEntries = List.copyOf(memberEntries);
403 }
404
405 @Override
406 public List<ClassEntry> nestMembers() {
407 return memberEntries;
408 }
409 }
410
411 public static final class UnboundNestHostAttribute
412 extends UnboundAttribute<NestHostAttribute>
413 implements NestHostAttribute {
414 private final ClassEntry hostEntry;
415
416 public UnboundNestHostAttribute(ClassEntry hostEntry) {
417 super(Attributes.nestHost());
418 this.hostEntry = requireNonNull(hostEntry);
419 }
420
421 @Override
422 public ClassEntry nestHost() {
423 return hostEntry;
424 }
425 }
426
427 public static final class UnboundCompilationIDAttribute
428 extends UnboundAttribute<CompilationIDAttribute>
429 implements CompilationIDAttribute {
430 private final Utf8Entry idEntry;
431
432 public UnboundCompilationIDAttribute(Utf8Entry idEntry) {
433 super(Attributes.compilationId());
434 this.idEntry = requireNonNull(idEntry);
435 }
436
437 @Override
438 public Utf8Entry compilationId() {
439 return idEntry;
440 }
441 }
442
443 public static final class UnboundSourceIDAttribute
444 extends UnboundAttribute<SourceIDAttribute>
445 implements SourceIDAttribute {
446 private final Utf8Entry idEntry;
447
448 public UnboundSourceIDAttribute(Utf8Entry idEntry) {
449 super(Attributes.sourceId());
450 this.idEntry = requireNonNull(idEntry);
451 }
452
453 @Override
454 public Utf8Entry sourceId() {
455 return idEntry;
456 }
457 }
458
459 public static final class UnboundSourceDebugExtensionAttribute
460 extends UnboundAttribute<SourceDebugExtensionAttribute>
461 implements SourceDebugExtensionAttribute {
462 private final byte[] contents;
463
464 public UnboundSourceDebugExtensionAttribute(byte[] contents) {
465 super(Attributes.sourceDebugExtension());
466 this.contents = requireNonNull(contents);
467 }
468
469 @Override
470 public byte[] contents() {
471 return contents;
472 }
473 }
474
475 public static final class UnboundCharacterRangeTableAttribute
476 extends UnboundAttribute<CharacterRangeTableAttribute>
477 implements CharacterRangeTableAttribute {
478 private final List<CharacterRangeInfo> ranges;
479
480 public UnboundCharacterRangeTableAttribute(List<CharacterRangeInfo> ranges) {
481 super(Attributes.characterRangeTable());
482 this.ranges = List.copyOf(ranges);
483 }
484
485 @Override
486 public List<CharacterRangeInfo> characterRangeTable() {
487 return ranges;
488 }
489 }
490
491 public static final class UnboundLineNumberTableAttribute
492 extends UnboundAttribute<LineNumberTableAttribute>
493 implements LineNumberTableAttribute {
494 private final List<LineNumberInfo> lines;
495
496 public UnboundLineNumberTableAttribute(List<LineNumberInfo> lines) {
497 super(Attributes.lineNumberTable());
498 this.lines = List.copyOf(lines);
499 }
500
501 @Override
502 public List<LineNumberInfo> lineNumbers() {
503 return lines;
504 }
505 }
506
507 public static final class UnboundLocalVariableTableAttribute
508 extends UnboundAttribute<LocalVariableTableAttribute>
509 implements LocalVariableTableAttribute {
510 private final List<LocalVariableInfo> locals;
511
512 public UnboundLocalVariableTableAttribute(List<LocalVariableInfo> locals) {
513 super(Attributes.localVariableTable());
514 this.locals = List.copyOf(locals);
515 }
516
517 @Override
518 public List<LocalVariableInfo> localVariables() {
519 return locals;
520 }
521 }
522
523 public static final class UnboundLocalVariableTypeTableAttribute
524 extends UnboundAttribute<LocalVariableTypeTableAttribute>
525 implements LocalVariableTypeTableAttribute {
526 private final List<LocalVariableTypeInfo> locals;
527
528 public UnboundLocalVariableTypeTableAttribute(List<LocalVariableTypeInfo> locals) {
529 super(Attributes.localVariableTypeTable());
530 this.locals = List.copyOf(locals);
531 }
532
533 @Override
534 public List<LocalVariableTypeInfo> localVariableTypes() {
535 return locals;
536 }
537 }
538
539 public static final class UnboundRuntimeVisibleAnnotationsAttribute
540 extends UnboundAttribute<RuntimeVisibleAnnotationsAttribute>
541 implements RuntimeVisibleAnnotationsAttribute {
542 private final List<Annotation> elements;
543
544 public UnboundRuntimeVisibleAnnotationsAttribute(List<Annotation> elements) {
545 super(Attributes.runtimeVisibleAnnotations());
546 this.elements = List.copyOf(elements);
547 }
548
549 @Override
550 public List<Annotation> annotations() {
551 return elements;
552 }
553 }
554
555 public static final class UnboundRuntimeInvisibleAnnotationsAttribute
556 extends UnboundAttribute<RuntimeInvisibleAnnotationsAttribute>
557 implements RuntimeInvisibleAnnotationsAttribute {
558 private final List<Annotation> elements;
559
560 public UnboundRuntimeInvisibleAnnotationsAttribute(List<Annotation> elements) {
561 super(Attributes.runtimeInvisibleAnnotations());
562 this.elements = List.copyOf(elements);
563 }
564
565 @Override
566 public List<Annotation> annotations() {
567 return elements;
568 }
569 }
570
571 public static final class UnboundRuntimeVisibleParameterAnnotationsAttribute
572 extends UnboundAttribute<RuntimeVisibleParameterAnnotationsAttribute>
573 implements RuntimeVisibleParameterAnnotationsAttribute {
574 private final List<List<Annotation>> elements;
575
576 public UnboundRuntimeVisibleParameterAnnotationsAttribute(List<List<Annotation>> elements) {
577 super(Attributes.runtimeVisibleParameterAnnotations());
578 // deep copy
579 var array = elements.toArray().clone();
580 for (int i = 0; i < array.length; i++) {
581 array[i] = List.copyOf((List<?>) array[i]);
582 }
583
584 this.elements = SharedSecrets.getJavaUtilCollectionAccess().listFromTrustedArray(array);
585 }
586
587 @Override
588 public List<List<Annotation>> parameterAnnotations() {
589 return elements;
590 }
591 }
592
593 public static final class UnboundRuntimeInvisibleParameterAnnotationsAttribute
594 extends UnboundAttribute<RuntimeInvisibleParameterAnnotationsAttribute>
595 implements RuntimeInvisibleParameterAnnotationsAttribute {
596 private final List<List<Annotation>> elements;
597
598 public UnboundRuntimeInvisibleParameterAnnotationsAttribute(List<List<Annotation>> elements) {
599 super(Attributes.runtimeInvisibleParameterAnnotations());
600 // deep copy
601 var array = elements.toArray().clone();
602 for (int i = 0; i < array.length; i++) {
603 array[i] = List.copyOf((List<?>) array[i]);
604 }
605
606 this.elements = SharedSecrets.getJavaUtilCollectionAccess().listFromTrustedArray(array);
607 }
608
609 @Override
610 public List<List<Annotation>> parameterAnnotations() {
611 return elements;
612 }
613 }
614
615 public static final class UnboundRuntimeVisibleTypeAnnotationsAttribute
616 extends UnboundAttribute<RuntimeVisibleTypeAnnotationsAttribute>
617 implements RuntimeVisibleTypeAnnotationsAttribute {
618 private final List<TypeAnnotation> elements;
619
620 public UnboundRuntimeVisibleTypeAnnotationsAttribute(List<TypeAnnotation> elements) {
621 super(Attributes.runtimeVisibleTypeAnnotations());
622 this.elements = List.copyOf(elements);
623 }
624
625 @Override
626 public List<TypeAnnotation> annotations() {
627 return elements;
628 }
629 }
630
631 public static final class UnboundRuntimeInvisibleTypeAnnotationsAttribute
632 extends UnboundAttribute<RuntimeInvisibleTypeAnnotationsAttribute>
633 implements RuntimeInvisibleTypeAnnotationsAttribute {
634 private final List<TypeAnnotation> elements;
635
636 public UnboundRuntimeInvisibleTypeAnnotationsAttribute(List<TypeAnnotation> elements) {
637 super(Attributes.runtimeInvisibleTypeAnnotations());
638 this.elements = List.copyOf(elements);
639 }
640
641 @Override
642 public List<TypeAnnotation> annotations() {
643 return elements;
644 }
645 }
646
647 public record UnboundCharacterRangeInfo(int startPc, int endPc,
648 int characterRangeStart,
649 int characterRangeEnd,
650 int flags)
651 implements CharacterRangeInfo { }
652
653 public record UnboundInnerClassInfo(ClassEntry innerClass,
654 Optional<ClassEntry> outerClass,
655 Optional<Utf8Entry> innerName,
656 int flagsMask)
657 implements InnerClassInfo {
658 public UnboundInnerClassInfo {
659 requireNonNull(innerClass);
660 requireNonNull(outerClass);
661 requireNonNull(innerName);
662 }
663 }
664
665 public record UnboundLineNumberInfo(int startPc, int lineNumber)
666 implements LineNumberInfo { }
667
668 public record UnboundLocalVariableInfo(int startPc, int length,
669 Utf8Entry name,
670 Utf8Entry type,
671 int slot)
672 implements LocalVariableInfo {
673 public UnboundLocalVariableInfo {
674 requireNonNull(name);
675 requireNonNull(type);
676 }
677 }
678
679 public record UnboundLocalVariableTypeInfo(int startPc, int length,
680 Utf8Entry name,
681 Utf8Entry signature,
682 int slot)
683 implements LocalVariableTypeInfo {
684 public UnboundLocalVariableTypeInfo {
685 requireNonNull(name);
686 requireNonNull(signature);
687 }
688 }
689
690 public record UnboundMethodParameterInfo(Optional<Utf8Entry> name, int flagsMask)
691 implements MethodParameterInfo {
692 public UnboundMethodParameterInfo {
693 requireNonNull(name);
694 }
695 }
696
697 public record UnboundModuleExportInfo(PackageEntry exportedPackage,
698 int exportsFlagsMask,
699 List<ModuleEntry> exportsTo)
700 implements ModuleExportInfo {
701 public UnboundModuleExportInfo {
702 requireNonNull(exportedPackage);
703 exportsTo = List.copyOf(exportsTo);
704 }
705 }
706
707 public record UnboundModuleHashInfo(ModuleEntry moduleName,
708 byte[] hash) implements ModuleHashInfo {
709 public UnboundModuleHashInfo {
710 requireNonNull(moduleName);
711 requireNonNull(hash);
712 }
713 }
714
715 public record UnboundModuleOpenInfo(PackageEntry openedPackage, int opensFlagsMask,
716 List<ModuleEntry> opensTo)
717 implements ModuleOpenInfo {
718 public UnboundModuleOpenInfo {
719 requireNonNull(openedPackage);
720 opensTo = List.copyOf(opensTo);
721 }
722 }
723
724 public record UnboundModuleProvideInfo(ClassEntry provides,
725 List<ClassEntry> providesWith)
726 implements ModuleProvideInfo {
727 public UnboundModuleProvideInfo {
728 requireNonNull(provides);
729 providesWith = List.copyOf(providesWith);
730 }
731 }
732
733 public record UnboundModuleRequiresInfo(ModuleEntry requires, int requiresFlagsMask,
734 Optional<Utf8Entry> requiresVersion)
735 implements ModuleRequireInfo {
736 public UnboundModuleRequiresInfo {
737 requireNonNull(requires);
738 requireNonNull(requiresVersion);
739 }
740 }
741
742 public record UnboundRecordComponentInfo(Utf8Entry name,
743 Utf8Entry descriptor,
744 List<Attribute<?>> attributes)
745 implements RecordComponentInfo {
746 public UnboundRecordComponentInfo {
747 requireNonNull(name);
748 requireNonNull(descriptor);
749 attributes = List.copyOf(attributes);
750 }
751 }
752
753 public record UnboundTypeAnnotation(TargetInfo targetInfo,
754 List<TypePathComponent> targetPath,
755 Annotation annotation) implements TypeAnnotation {
756
757 public UnboundTypeAnnotation {
758 requireNonNull(targetInfo);
759 targetPath = List.copyOf(targetPath);
760 requireNonNull(annotation);
761 }
762 }
763
764 public record TypePathComponentImpl(TypeAnnotation.TypePathComponent.Kind typePathKind, int typeArgumentIndex)
765 implements TypeAnnotation.TypePathComponent {}
766
767 public static final class UnboundModuleAttribute extends UnboundAttribute<ModuleAttribute> implements ModuleAttribute {
768 private final ModuleEntry moduleName;
769 private final int moduleFlags;
770 private final Utf8Entry moduleVersion;
771 private final List<ModuleRequireInfo> requires;
772 private final List<ModuleExportInfo> exports;
773 private final List<ModuleOpenInfo> opens;
774 private final List<ClassEntry> uses;
775 private final List<ModuleProvideInfo> provides;
776
777 public UnboundModuleAttribute(ModuleEntry moduleName,
778 int moduleFlags,
779 Utf8Entry moduleVersion,
780 Collection<ModuleRequireInfo> requires,
781 Collection<ModuleExportInfo> exports,
782 Collection<ModuleOpenInfo> opens,
783 Collection<ClassEntry> uses,
784 Collection<ModuleProvideInfo> provides)
785 {
786 super(Attributes.module());
787 this.moduleName = requireNonNull(moduleName);
788 this.moduleFlags = moduleFlags;
789 this.moduleVersion = moduleVersion;
790 this.requires = List.copyOf(requires);
791 this.exports = List.copyOf(exports);
792 this.opens = List.copyOf(opens);
793 this.uses = List.copyOf(uses);
794 this.provides = List.copyOf(provides);
795 }
796
797 @Override
798 public ModuleEntry moduleName() {
799 return moduleName;
800 }
801
802 @Override
803 public int moduleFlagsMask() {
804 return moduleFlags;
805 }
806
807 @Override
808 public Optional<Utf8Entry> moduleVersion() {
809 return Optional.ofNullable(moduleVersion);
810 }
811
812 @Override
813 public List<ModuleRequireInfo> requires() {
814 return requires;
815 }
816
817 @Override
818 public List<ModuleExportInfo> exports() {
819 return exports;
820 }
821
822 @Override
823 public List<ModuleOpenInfo> opens() {
824 return opens;
825 }
826
827 @Override
828 public List<ClassEntry> uses() {
829 return uses;
830 }
831
832 @Override
833 public List<ModuleProvideInfo> provides() {
834 return provides;
835 }
836 }
837
838 public abstract static non-sealed class AdHocAttribute<T extends Attribute<T>>
839 extends UnboundAttribute<T> {
840
841 public AdHocAttribute(AttributeMapper<T> mapper) {
842 super(mapper);
843 }
844
845 public abstract void writeBody(BufWriterImpl b);
846
847 @Override
848 public void writeTo(BufWriterImpl b) {
849 b.writeIndex(b.constantPool().utf8Entry(mapper.name()));
850 int lengthIndex = b.skip(4);
851 writeBody(b);
852 int written = b.size() - lengthIndex - 4;
853 b.patchInt(lengthIndex, written);
854 }
855 }
856
857 public static final class EmptyBootstrapAttribute
858 extends UnboundAttribute<BootstrapMethodsAttribute>
859 implements BootstrapMethodsAttribute {
860 public EmptyBootstrapAttribute() {
861 super(Attributes.bootstrapMethods());
862 }
863
864 @Override
865 public int bootstrapMethodsSize() {
866 return 0;
867 }
868
869 @Override
870 public List<BootstrapMethodEntry> bootstrapMethods() {
871 return List.of();
872 }
873 }
874 }