1 /*
  2  * Copyright (c) 2022, 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.util.Collection;
 28 import java.util.List;
 29 import java.util.Optional;
 30 
 31 import jdk.internal.classfile.Annotation;
 32 import jdk.internal.classfile.AnnotationElement;
 33 import jdk.internal.classfile.AnnotationValue;
 34 import jdk.internal.classfile.Attribute;
 35 import jdk.internal.classfile.AttributeMapper;
 36 import jdk.internal.classfile.Attributes;
 37 import jdk.internal.classfile.BootstrapMethodEntry;
 38 import jdk.internal.classfile.BufWriter;
 39 import jdk.internal.classfile.constantpool.ClassEntry;
 40 import jdk.internal.classfile.Label;
 41 import jdk.internal.classfile.TypeAnnotation;
 42 import jdk.internal.classfile.attribute.AnnotationDefaultAttribute;
 43 import jdk.internal.classfile.attribute.BootstrapMethodsAttribute;
 44 import jdk.internal.classfile.attribute.CharacterRangeInfo;
 45 import jdk.internal.classfile.attribute.CharacterRangeTableAttribute;
 46 import jdk.internal.classfile.attribute.CompilationIDAttribute;
 47 import jdk.internal.classfile.attribute.ConstantValueAttribute;
 48 import jdk.internal.classfile.attribute.DeprecatedAttribute;
 49 import jdk.internal.classfile.attribute.EnclosingMethodAttribute;
 50 import jdk.internal.classfile.attribute.ExceptionsAttribute;
 51 import jdk.internal.classfile.attribute.InnerClassInfo;
 52 import jdk.internal.classfile.attribute.InnerClassesAttribute;
 53 import jdk.internal.classfile.attribute.LineNumberInfo;
 54 import jdk.internal.classfile.attribute.LineNumberTableAttribute;
 55 import jdk.internal.classfile.attribute.LocalVariableInfo;
 56 import jdk.internal.classfile.attribute.LocalVariableTableAttribute;
 57 import jdk.internal.classfile.attribute.LocalVariableTypeInfo;
 58 import jdk.internal.classfile.attribute.LocalVariableTypeTableAttribute;
 59 import jdk.internal.classfile.attribute.MethodParameterInfo;
 60 import jdk.internal.classfile.attribute.MethodParametersAttribute;
 61 import jdk.internal.classfile.attribute.ModuleAttribute;
 62 import jdk.internal.classfile.attribute.ModuleExportInfo;
 63 import jdk.internal.classfile.attribute.ModuleHashInfo;
 64 import jdk.internal.classfile.attribute.ModuleHashesAttribute;
 65 import jdk.internal.classfile.attribute.ModuleMainClassAttribute;
 66 import jdk.internal.classfile.attribute.ModuleOpenInfo;
 67 import jdk.internal.classfile.attribute.ModulePackagesAttribute;
 68 import jdk.internal.classfile.attribute.ModuleProvideInfo;
 69 import jdk.internal.classfile.attribute.ModuleRequireInfo;
 70 import jdk.internal.classfile.attribute.ModuleResolutionAttribute;
 71 import jdk.internal.classfile.attribute.ModuleTargetAttribute;
 72 import jdk.internal.classfile.attribute.NestHostAttribute;
 73 import jdk.internal.classfile.attribute.NestMembersAttribute;
 74 import jdk.internal.classfile.attribute.PermittedSubclassesAttribute;
 75 import jdk.internal.classfile.attribute.RecordAttribute;
 76 import jdk.internal.classfile.attribute.RecordComponentInfo;
 77 import jdk.internal.classfile.attribute.RuntimeInvisibleAnnotationsAttribute;
 78 import jdk.internal.classfile.attribute.RuntimeInvisibleParameterAnnotationsAttribute;
 79 import jdk.internal.classfile.attribute.RuntimeInvisibleTypeAnnotationsAttribute;
 80 import jdk.internal.classfile.attribute.RuntimeVisibleAnnotationsAttribute;
 81 import jdk.internal.classfile.attribute.RuntimeVisibleParameterAnnotationsAttribute;
 82 import jdk.internal.classfile.attribute.RuntimeVisibleTypeAnnotationsAttribute;
 83 import jdk.internal.classfile.attribute.SignatureAttribute;
 84 import jdk.internal.classfile.attribute.SourceDebugExtensionAttribute;
 85 import jdk.internal.classfile.attribute.SourceFileAttribute;
 86 import jdk.internal.classfile.attribute.SourceIDAttribute;
 87 import jdk.internal.classfile.attribute.StackMapTableAttribute;
 88 import jdk.internal.classfile.attribute.StackMapFrameInfo;
 89 import jdk.internal.classfile.attribute.SyntheticAttribute;
 90 import jdk.internal.classfile.constantpool.ConstantValueEntry;
 91 import jdk.internal.classfile.constantpool.ModuleEntry;
 92 import jdk.internal.classfile.constantpool.NameAndTypeEntry;
 93 import jdk.internal.classfile.constantpool.PackageEntry;
 94 import jdk.internal.classfile.constantpool.Utf8Entry;
 95 
 96 public abstract sealed class UnboundAttribute<T extends Attribute<T>>
 97         extends AbstractElement
 98         implements Attribute<T> {
 99     protected final AttributeMapper<T> mapper;
100 
101     public UnboundAttribute(AttributeMapper<T> mapper) {
102         this.mapper = mapper;
103     }
104 
105     @Override
106     public AttributeMapper<T> attributeMapper() {
107         return mapper;
108     }
109 
110     @Override
111     public String attributeName() {
112         return mapper.name();
113     }
114 
115     @Override
116     @SuppressWarnings("unchecked")
117     public void writeTo(BufWriter buf) {
118         mapper.writeAttribute(buf, (T) this);
119     }
120 
121     @Override
122     public void writeTo(DirectClassBuilder builder) {
123         builder.writeAttribute(this);
124     }
125 
126     @Override
127     public void writeTo(DirectCodeBuilder builder) {
128         builder.writeAttribute(this);
129     }
130 
131     @Override
132     public void writeTo(DirectMethodBuilder builder) {
133         builder.writeAttribute(this);
134     }
135 
136     @Override
137     public void writeTo(DirectFieldBuilder builder) {
138         builder.writeAttribute(this);
139     }
140 
141     @Override
142     public String toString() {
143         return String.format("Attribute[name=%s]", mapper.name());
144     }
145     public static final class UnboundConstantValueAttribute
146             extends UnboundAttribute<ConstantValueAttribute>
147             implements ConstantValueAttribute {
148 
149         private final ConstantValueEntry entry;
150 
151         public UnboundConstantValueAttribute(ConstantValueEntry entry) {
152             super(Attributes.CONSTANT_VALUE);
153             this.entry = entry;
154         }
155 
156         @Override
157         public ConstantValueEntry constant() {
158             return entry;
159         }
160 
161     }
162 
163     public static final class UnboundDeprecatedAttribute
164             extends UnboundAttribute<DeprecatedAttribute>
165             implements DeprecatedAttribute {
166         public UnboundDeprecatedAttribute() {
167             super(Attributes.DEPRECATED);
168         }
169     }
170 
171     public static final class UnboundSyntheticAttribute
172             extends UnboundAttribute<SyntheticAttribute>
173             implements SyntheticAttribute {
174         public UnboundSyntheticAttribute() {
175             super(Attributes.SYNTHETIC);
176         }
177     }
178 
179     public static final class UnboundSignatureAttribute
180             extends UnboundAttribute<SignatureAttribute>
181             implements SignatureAttribute {
182         private final Utf8Entry signature;
183 
184         public UnboundSignatureAttribute(Utf8Entry signature) {
185             super(Attributes.SIGNATURE);
186             this.signature = signature;
187         }
188 
189         @Override
190         public Utf8Entry signature() {
191             return signature;
192         }
193     }
194 
195     public static final class UnboundExceptionsAttribute
196             extends UnboundAttribute<ExceptionsAttribute>
197             implements ExceptionsAttribute {
198         private final List<ClassEntry> exceptions;
199 
200         public UnboundExceptionsAttribute(List<ClassEntry> exceptions) {
201             super(Attributes.EXCEPTIONS);
202             this.exceptions = List.copyOf(exceptions);
203         }
204 
205         @Override
206         public List<ClassEntry> exceptions() {
207             return exceptions;
208         }
209     }
210 
211     public static final class UnboundAnnotationDefaultAttribute
212             extends UnboundAttribute<AnnotationDefaultAttribute>
213             implements AnnotationDefaultAttribute {
214         private final AnnotationValue annotationDefault;
215 
216         public UnboundAnnotationDefaultAttribute(AnnotationValue annotationDefault) {
217             super(Attributes.ANNOTATION_DEFAULT);
218             this.annotationDefault = annotationDefault;
219         }
220 
221         @Override
222         public AnnotationValue defaultValue() {
223             return annotationDefault;
224         }
225     }
226 
227     public static final class UnboundSourceFileAttribute extends UnboundAttribute<SourceFileAttribute>
228             implements SourceFileAttribute {
229         private final Utf8Entry sourceFile;
230 
231         public UnboundSourceFileAttribute(Utf8Entry sourceFile) {
232             super(Attributes.SOURCE_FILE);
233             this.sourceFile = sourceFile;
234         }
235 
236         @Override
237         public Utf8Entry sourceFile() {
238             return sourceFile;
239         }
240 
241     }
242 
243     public static final class UnboundStackMapTableAttribute extends UnboundAttribute<StackMapTableAttribute>
244             implements StackMapTableAttribute {
245         private final List<StackMapFrameInfo> entries;
246 
247         public UnboundStackMapTableAttribute(List<StackMapFrameInfo> entries) {
248             super(Attributes.STACK_MAP_TABLE);
249             this.entries = List.copyOf(entries);
250         }
251 
252         @Override
253         public List<StackMapFrameInfo> entries() {
254             return entries;
255         }
256     }
257 
258     public static final class UnboundInnerClassesAttribute
259             extends UnboundAttribute<InnerClassesAttribute>
260             implements InnerClassesAttribute {
261         private final List<InnerClassInfo> innerClasses;
262 
263         public UnboundInnerClassesAttribute(List<InnerClassInfo> innerClasses) {
264             super(Attributes.INNER_CLASSES);
265             this.innerClasses = List.copyOf(innerClasses);
266         }
267 
268         @Override
269         public List<InnerClassInfo> classes() {
270             return innerClasses;
271         }
272     }
273 
274     public static final class UnboundRecordAttribute
275             extends UnboundAttribute<RecordAttribute>
276             implements RecordAttribute {
277         private final List<RecordComponentInfo> components;
278 
279         public UnboundRecordAttribute(List<RecordComponentInfo> components) {
280             super(Attributes.RECORD);
281             this.components = List.copyOf(components);
282         }
283 
284         @Override
285         public List<RecordComponentInfo> components() {
286             return components;
287         }
288     }
289 
290     public static final class UnboundEnclosingMethodAttribute
291             extends UnboundAttribute<EnclosingMethodAttribute>
292             implements EnclosingMethodAttribute {
293         private final ClassEntry classEntry;
294         private final NameAndTypeEntry method;
295 
296         public UnboundEnclosingMethodAttribute(ClassEntry classEntry, NameAndTypeEntry method) {
297             super(Attributes.ENCLOSING_METHOD);
298             this.classEntry = classEntry;
299             this.method = method;
300         }
301 
302         @Override
303         public ClassEntry enclosingClass() {
304             return classEntry;
305         }
306 
307         @Override
308         public Optional<NameAndTypeEntry> enclosingMethod() {
309             return Optional.ofNullable(method);
310         }
311     }
312 
313     public static final class UnboundMethodParametersAttribute
314             extends UnboundAttribute<MethodParametersAttribute>
315             implements MethodParametersAttribute {
316         private final List<MethodParameterInfo> parameters;
317 
318         public UnboundMethodParametersAttribute(List<MethodParameterInfo> parameters) {
319             super(Attributes.METHOD_PARAMETERS);
320             this.parameters = List.copyOf(parameters);
321         }
322 
323         @Override
324         public List<MethodParameterInfo> parameters() {
325             return parameters;
326         }
327     }
328 
329     public static final class UnboundModuleTargetAttribute
330             extends UnboundAttribute<ModuleTargetAttribute>
331             implements ModuleTargetAttribute {
332         final Utf8Entry moduleTarget;
333 
334         public UnboundModuleTargetAttribute(Utf8Entry moduleTarget) {
335             super(Attributes.MODULE_TARGET);
336             this.moduleTarget = moduleTarget;
337         }
338 
339         @Override
340         public Utf8Entry targetPlatform() {
341             return moduleTarget;
342         }
343     }
344 
345     public static final class UnboundModuleMainClassAttribute
346             extends UnboundAttribute<ModuleMainClassAttribute>
347             implements ModuleMainClassAttribute {
348         final ClassEntry mainClass;
349 
350         public UnboundModuleMainClassAttribute(ClassEntry mainClass) {
351             super(Attributes.MODULE_MAIN_CLASS);
352             this.mainClass = mainClass;
353         }
354 
355         @Override
356         public ClassEntry mainClass() {
357             return mainClass;
358         }
359     }
360 
361     public static final class UnboundModuleHashesAttribute
362             extends UnboundAttribute<ModuleHashesAttribute>
363             implements ModuleHashesAttribute {
364         private final Utf8Entry algorithm;
365         private final List<ModuleHashInfo> hashes;
366 
367         public UnboundModuleHashesAttribute(Utf8Entry algorithm, List<ModuleHashInfo> hashes) {
368             super(Attributes.MODULE_HASHES);
369             this.algorithm = algorithm;
370             this.hashes = List.copyOf(hashes);
371         }
372 
373         @Override
374         public Utf8Entry algorithm() {
375             return algorithm;
376         }
377 
378         @Override
379         public List<ModuleHashInfo> hashes() {
380             return hashes;
381         }
382     }
383 
384     public static final class UnboundModulePackagesAttribute
385             extends UnboundAttribute<ModulePackagesAttribute>
386             implements ModulePackagesAttribute {
387         private final Collection<PackageEntry> packages;
388 
389         public UnboundModulePackagesAttribute(Collection<PackageEntry> packages) {
390             super(Attributes.MODULE_PACKAGES);
391             this.packages = List.copyOf(packages);
392         }
393 
394         @Override
395         public List<PackageEntry> packages() {
396             return List.copyOf(packages);
397         }
398     }
399 
400     public static final class UnboundModuleResolutionAttribute
401             extends UnboundAttribute<ModuleResolutionAttribute>
402             implements ModuleResolutionAttribute {
403         private final int resolutionFlags;
404 
405         public UnboundModuleResolutionAttribute(int flags) {
406             super(Attributes.MODULE_RESOLUTION);
407             resolutionFlags = flags;
408         }
409 
410         @Override
411         public int resolutionFlags() {
412             return resolutionFlags;
413         }
414     }
415 
416     public static final class UnboundPermittedSubclassesAttribute
417             extends UnboundAttribute<PermittedSubclassesAttribute>
418             implements PermittedSubclassesAttribute {
419         private final List<ClassEntry> permittedSubclasses;
420 
421         public UnboundPermittedSubclassesAttribute(List<ClassEntry> permittedSubclasses) {
422             super(Attributes.PERMITTED_SUBCLASSES);
423             this.permittedSubclasses = List.copyOf(permittedSubclasses);
424         }
425 
426         @Override
427         public List<ClassEntry> permittedSubclasses() {
428             return permittedSubclasses;
429         }
430     }
431 
432     public static final class UnboundNestMembersAttribute
433             extends UnboundAttribute<NestMembersAttribute>
434             implements NestMembersAttribute {
435         private final List<ClassEntry> memberEntries;
436 
437         public UnboundNestMembersAttribute(List<ClassEntry> memberEntries) {
438             super(Attributes.NEST_MEMBERS);
439             this.memberEntries = List.copyOf(memberEntries);
440         }
441 
442         @Override
443         public List<ClassEntry> nestMembers() {
444             return memberEntries;
445         }
446     }
447 
448     public static final class UnboundNestHostAttribute
449             extends UnboundAttribute<NestHostAttribute>
450             implements NestHostAttribute {
451         private final ClassEntry hostEntry;
452 
453         public UnboundNestHostAttribute(ClassEntry hostEntry) {
454             super(Attributes.NEST_HOST);
455             this.hostEntry = hostEntry;
456         }
457 
458         @Override
459         public ClassEntry nestHost() {
460             return hostEntry;
461         }
462     }
463 
464     public static final class UnboundCompilationIDAttribute
465             extends UnboundAttribute<CompilationIDAttribute>
466             implements CompilationIDAttribute {
467         private final Utf8Entry idEntry;
468 
469         public UnboundCompilationIDAttribute(Utf8Entry idEntry) {
470             super(Attributes.COMPILATION_ID);
471             this.idEntry = idEntry;
472         }
473 
474         @Override
475         public Utf8Entry compilationId() {
476             return idEntry;
477         }
478     }
479 
480     public static final class UnboundSourceIDAttribute
481             extends UnboundAttribute<SourceIDAttribute>
482             implements SourceIDAttribute {
483         private final Utf8Entry idEntry;
484 
485         public UnboundSourceIDAttribute(Utf8Entry idEntry) {
486             super(Attributes.SOURCE_ID);
487             this.idEntry = idEntry;
488         }
489 
490         @Override
491         public Utf8Entry sourceId() {
492             return idEntry;
493         }
494     }
495 
496     public static final class UnboundSourceDebugExtensionAttribute
497         extends UnboundAttribute<SourceDebugExtensionAttribute>
498             implements SourceDebugExtensionAttribute {
499         private final byte[] contents;
500 
501         public UnboundSourceDebugExtensionAttribute(byte[] contents) {
502             super(Attributes.SOURCE_DEBUG_EXTENSION);
503             this.contents = contents;
504         }
505 
506         @Override
507         public byte[] contents() {
508             return contents;
509         }
510     }
511 
512     public static final class UnboundCharacterRangeTableAttribute
513         extends UnboundAttribute<CharacterRangeTableAttribute>
514             implements CharacterRangeTableAttribute {
515         private final List<CharacterRangeInfo> ranges;
516 
517         public UnboundCharacterRangeTableAttribute(List<CharacterRangeInfo> ranges) {
518             super(Attributes.CHARACTER_RANGE_TABLE);
519             this.ranges = List.copyOf(ranges);
520         }
521 
522         @Override
523         public List<CharacterRangeInfo> characterRangeTable() {
524             return ranges;
525         }
526     }
527 
528     public static final class UnboundLineNumberTableAttribute
529         extends UnboundAttribute<LineNumberTableAttribute>
530             implements LineNumberTableAttribute {
531         private final List<LineNumberInfo> lines;
532 
533         public UnboundLineNumberTableAttribute(List<LineNumberInfo> lines) {
534             super(Attributes.LINE_NUMBER_TABLE);
535             this.lines = List.copyOf(lines);
536         }
537 
538         @Override
539         public List<LineNumberInfo> lineNumbers() {
540             return lines;
541         }
542     }
543 
544     public static final class UnboundLocalVariableTableAttribute
545         extends UnboundAttribute<LocalVariableTableAttribute>
546             implements LocalVariableTableAttribute {
547         private final List<LocalVariableInfo> locals;
548 
549         public UnboundLocalVariableTableAttribute(List<LocalVariableInfo> locals) {
550             super(Attributes.LOCAL_VARIABLE_TABLE);
551             this.locals = List.copyOf(locals);
552         }
553 
554         @Override
555         public List<LocalVariableInfo> localVariables() {
556             return locals;
557         }
558     }
559 
560     public static final class UnboundLocalVariableTypeTableAttribute
561         extends UnboundAttribute<LocalVariableTypeTableAttribute>
562             implements LocalVariableTypeTableAttribute {
563         private final List<LocalVariableTypeInfo> locals;
564 
565         public UnboundLocalVariableTypeTableAttribute(List<LocalVariableTypeInfo> locals) {
566             super(Attributes.LOCAL_VARIABLE_TYPE_TABLE);
567             this.locals = List.copyOf(locals);
568         }
569 
570         @Override
571         public List<LocalVariableTypeInfo> localVariableTypes() {
572             return locals;
573         }
574     }
575 
576     public static final class UnboundRuntimeVisibleAnnotationsAttribute
577             extends UnboundAttribute<RuntimeVisibleAnnotationsAttribute>
578             implements RuntimeVisibleAnnotationsAttribute {
579         private final List<Annotation> elements;
580 
581         public UnboundRuntimeVisibleAnnotationsAttribute(List<Annotation> elements) {
582             super(Attributes.RUNTIME_VISIBLE_ANNOTATIONS);
583             this.elements = List.copyOf(elements);
584         }
585 
586         @Override
587         public List<Annotation> annotations() {
588             return elements;
589         }
590     }
591 
592     public static final class UnboundRuntimeInvisibleAnnotationsAttribute
593             extends UnboundAttribute<RuntimeInvisibleAnnotationsAttribute>
594             implements RuntimeInvisibleAnnotationsAttribute {
595         private final List<Annotation> elements;
596 
597         public UnboundRuntimeInvisibleAnnotationsAttribute(List<Annotation> elements) {
598             super(Attributes.RUNTIME_INVISIBLE_ANNOTATIONS);
599             this.elements = List.copyOf(elements);
600         }
601 
602         @Override
603         public List<Annotation> annotations() {
604             return elements;
605         }
606     }
607 
608     public static final class UnboundRuntimeVisibleParameterAnnotationsAttribute
609             extends UnboundAttribute<RuntimeVisibleParameterAnnotationsAttribute>
610             implements RuntimeVisibleParameterAnnotationsAttribute {
611         private final List<List<Annotation>> elements;
612 
613         public UnboundRuntimeVisibleParameterAnnotationsAttribute(List<List<Annotation>> elements) {
614             super(Attributes.RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS);
615             this.elements = List.copyOf(elements);
616         }
617 
618         @Override
619         public List<List<Annotation>> parameterAnnotations() {
620             return elements;
621         }
622     }
623 
624     public static final class UnboundRuntimeInvisibleParameterAnnotationsAttribute
625             extends UnboundAttribute<RuntimeInvisibleParameterAnnotationsAttribute>
626             implements RuntimeInvisibleParameterAnnotationsAttribute {
627         private final List<List<Annotation>> elements;
628 
629         public UnboundRuntimeInvisibleParameterAnnotationsAttribute(List<List<Annotation>> elements) {
630             super(Attributes.RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS);
631             this.elements = List.copyOf(elements);
632         }
633 
634         @Override
635         public List<List<Annotation>> parameterAnnotations() {
636             return elements;
637         }
638     }
639 
640     public static final class UnboundRuntimeVisibleTypeAnnotationsAttribute
641             extends UnboundAttribute<RuntimeVisibleTypeAnnotationsAttribute>
642             implements RuntimeVisibleTypeAnnotationsAttribute {
643         private final List<TypeAnnotation> elements;
644 
645         public UnboundRuntimeVisibleTypeAnnotationsAttribute(List<TypeAnnotation> elements) {
646             super(Attributes.RUNTIME_VISIBLE_TYPE_ANNOTATIONS);
647             this.elements = List.copyOf(elements);
648         }
649 
650         @Override
651         public List<TypeAnnotation> annotations() {
652             return elements;
653         }
654     }
655 
656     public static final class UnboundRuntimeInvisibleTypeAnnotationsAttribute
657             extends UnboundAttribute<RuntimeInvisibleTypeAnnotationsAttribute>
658             implements RuntimeInvisibleTypeAnnotationsAttribute {
659         private final List<TypeAnnotation> elements;
660 
661         public UnboundRuntimeInvisibleTypeAnnotationsAttribute(List<TypeAnnotation> elements) {
662             super(Attributes.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS);
663             this.elements = List.copyOf(elements);
664         }
665 
666         @Override
667         public List<TypeAnnotation> annotations() {
668             return elements;
669         }
670     }
671 
672     public record UnboundCharacterRangeInfo(int startPc, int endPc,
673                                             int characterRangeStart,
674                                             int characterRangeEnd,
675                                             int flags)
676             implements CharacterRangeInfo { }
677 
678     public record UnboundInnerClassInfo(ClassEntry innerClass,
679                                         Optional<ClassEntry> outerClass,
680                                         Optional<Utf8Entry> innerName,
681                                         int flagsMask)
682             implements InnerClassInfo {}
683 
684     public record UnboundLineNumberInfo(int startPc, int lineNumber)
685             implements LineNumberInfo { }
686 
687     public record UnboundLocalVariableInfo(int startPc, int length,
688                                            Utf8Entry name,
689                                            Utf8Entry type,
690                                            int slot)
691             implements LocalVariableInfo { }
692 
693     public record UnboundLocalVariableTypeInfo(int startPc, int length,
694                                                Utf8Entry name,
695                                                Utf8Entry signature,
696                                                int slot)
697             implements LocalVariableTypeInfo { }
698 
699     public record UnboundMethodParameterInfo(Optional<Utf8Entry> name, int flagsMask)
700             implements MethodParameterInfo {}
701 
702     public record UnboundModuleExportInfo(PackageEntry exportedPackage,
703                                           int exportsFlagsMask,
704                                           List<ModuleEntry> exportsTo)
705             implements ModuleExportInfo {
706         public UnboundModuleExportInfo(PackageEntry exportedPackage, int exportsFlagsMask,
707                                        List<ModuleEntry> exportsTo) {
708             this.exportedPackage = exportedPackage;
709             this.exportsFlagsMask = exportsFlagsMask;
710             this.exportsTo = List.copyOf(exportsTo);
711         }
712     }
713 
714     public record UnboundModuleHashInfo(ModuleEntry moduleName,
715                                         byte[] hash) implements ModuleHashInfo { }
716 
717     public record UnboundModuleOpenInfo(PackageEntry openedPackage, int opensFlagsMask,
718                                         List<ModuleEntry> opensTo)
719             implements ModuleOpenInfo {
720         public UnboundModuleOpenInfo(PackageEntry openedPackage, int opensFlagsMask,
721                                      List<ModuleEntry> opensTo) {
722             this.openedPackage = openedPackage;
723             this.opensFlagsMask = opensFlagsMask;
724             this.opensTo = List.copyOf(opensTo);
725         }
726     }
727 
728     public record UnboundModuleProvideInfo(ClassEntry provides,
729                                            List<ClassEntry> providesWith)
730             implements ModuleProvideInfo {
731         public UnboundModuleProvideInfo(ClassEntry provides, List<ClassEntry> providesWith) {
732             this.provides = provides;
733             this.providesWith = List.copyOf(providesWith);
734         }
735     }
736 
737     public record UnboundModuleRequiresInfo(ModuleEntry requires, int requiresFlagsMask,
738                                             Optional<Utf8Entry> requiresVersion)
739             implements ModuleRequireInfo {}
740 
741     public record UnboundRecordComponentInfo(Utf8Entry name,
742                                              Utf8Entry descriptor,
743                                              List<Attribute<?>> attributes)
744             implements RecordComponentInfo {
745         public UnboundRecordComponentInfo(Utf8Entry name, Utf8Entry descriptor, List<Attribute<?>> attributes) {
746             this.name = name;
747             this.descriptor = descriptor;
748             this.attributes = List.copyOf(attributes);
749         }
750     }
751 
752     public record UnboundTypeAnnotation(TargetInfo targetInfo,
753                                         List<TypePathComponent> targetPath,
754                                         Utf8Entry className,
755                                         List<AnnotationElement> elements) implements TypeAnnotation {
756 
757         public UnboundTypeAnnotation(TargetInfo targetInfo, List<TypePathComponent> targetPath,
758                                      Utf8Entry className, List<AnnotationElement> elements) {
759             this.targetInfo = targetInfo;
760             this.targetPath = List.copyOf(targetPath);
761             this.className = className;
762             this.elements = List.copyOf(elements);
763         }
764 
765         private int labelToBci(LabelContext lr, Label label) {
766             //helper method to avoid NPE
767             if (lr == null) throw new IllegalArgumentException("Illegal targetType '%s' in TypeAnnotation outside of Code attribute".formatted(targetInfo.targetType()));
768             return lr.labelToBci(label);
769         }
770 
771         @Override
772         public void writeTo(BufWriter buf) {
773             LabelContext lr = ((BufWriterImpl) buf).labelContext();
774             // target_type
775             buf.writeU1(targetInfo.targetType().targetTypeValue());
776 
777             // target_info
778             switch (targetInfo) {
779                 case TypeParameterTarget tpt -> buf.writeU1(tpt.typeParameterIndex());
780                 case SupertypeTarget st -> buf.writeU2(st.supertypeIndex());
781                 case TypeParameterBoundTarget tpbt -> {
782                     buf.writeU1(tpbt.typeParameterIndex());
783                     buf.writeU1(tpbt.boundIndex());
784                 }
785                 case EmptyTarget et -> {
786                     // nothing to write
787                 }
788                 case FormalParameterTarget fpt -> buf.writeU1(fpt.formalParameterIndex());
789                 case ThrowsTarget tt -> buf.writeU2(tt.throwsTargetIndex());
790                 case LocalVarTarget lvt -> {
791                     buf.writeU2(lvt.table().size());
792                     for (var e : lvt.table()) {
793                         int startPc = labelToBci(lr, e.startLabel());
794                         buf.writeU2(startPc);
795                         buf.writeU2(labelToBci(lr, e.endLabel()) - startPc);
796                         buf.writeU2(e.index());
797                     }
798                 }
799                 case CatchTarget ct -> buf.writeU2(ct.exceptionTableIndex());
800                 case OffsetTarget ot -> buf.writeU2(labelToBci(lr, ot.target()));
801                 case TypeArgumentTarget tat -> {
802                     buf.writeU2(labelToBci(lr, tat.target()));
803                     buf.writeU1(tat.typeArgumentIndex());
804                 }
805             }
806 
807             // target_path
808             buf.writeU1(targetPath().size());
809             for (TypePathComponent component : targetPath()) {
810                 buf.writeU1(component.typePathKind().tag());
811                 buf.writeU1(component.typeArgumentIndex());
812             }
813 
814             // type_index
815             buf.writeIndex(className);
816 
817             // element_value_pairs
818             buf.writeU2(elements.size());
819             for (AnnotationElement pair : elements()) {
820                 buf.writeIndex(pair.name());
821                 pair.value().writeTo(buf);
822             }
823         }
824     }
825 
826     public record TypePathComponentImpl(TypeAnnotation.TypePathComponent.Kind typePathKind, int typeArgumentIndex)
827             implements TypeAnnotation.TypePathComponent {}
828 
829     public static final class UnboundModuleAttribute extends UnboundAttribute<ModuleAttribute> implements ModuleAttribute {
830         private final ModuleEntry moduleName;
831         private final int moduleFlags;
832         private final Utf8Entry moduleVersion;
833         private final List<ModuleRequireInfo> requires;
834         private final List<ModuleExportInfo> exports;
835         private final List<ModuleOpenInfo> opens;
836         private final List<ClassEntry> uses;
837         private final List<ModuleProvideInfo> provides;
838 
839         public UnboundModuleAttribute(ModuleEntry moduleName,
840                                       int moduleFlags,
841                                       Utf8Entry moduleVersion,
842                                       Collection<ModuleRequireInfo> requires,
843                                       Collection<ModuleExportInfo> exports,
844                                       Collection<ModuleOpenInfo> opens,
845                                       Collection<ClassEntry> uses,
846                                       Collection<ModuleProvideInfo> provides)
847         {
848             super(Attributes.MODULE);
849             this.moduleName = moduleName;
850             this.moduleFlags = moduleFlags;
851             this.moduleVersion = moduleVersion;
852             this.requires = List.copyOf(requires);
853             this.exports = List.copyOf(exports);
854             this.opens = List.copyOf(opens);
855             this.uses = List.copyOf(uses);
856             this.provides = List.copyOf(provides);
857         }
858 
859         @Override
860         public ModuleEntry moduleName() {
861             return moduleName;
862         }
863 
864         @Override
865         public int moduleFlagsMask() {
866             return moduleFlags;
867         }
868 
869         @Override
870         public Optional<Utf8Entry> moduleVersion() {
871             return Optional.ofNullable(moduleVersion);
872         }
873 
874         @Override
875         public List<ModuleRequireInfo> requires() {
876             return requires;
877         }
878 
879         @Override
880         public List<ModuleExportInfo> exports() {
881             return exports;
882         }
883 
884         @Override
885         public List<ModuleOpenInfo> opens() {
886             return opens;
887         }
888 
889         @Override
890         public List<ClassEntry> uses() {
891             return uses;
892         }
893 
894         @Override
895         public List<ModuleProvideInfo> provides() {
896             return provides;
897         }
898     }
899 
900     public static abstract non-sealed class AdHocAttribute<T extends Attribute<T>>
901             extends UnboundAttribute<T> {
902 
903         public AdHocAttribute(AttributeMapper<T> mapper) {
904             super(mapper);
905         }
906 
907         public abstract void writeBody(BufWriter b);
908 
909         @Override
910         public void writeTo(BufWriter b) {
911             b.writeIndex(b.constantPool().utf8Entry(mapper.name()));
912             b.writeInt(0);
913             int start = b.size();
914             writeBody(b);
915             int written = b.size() - start;
916             b.patchInt(start - 4, 4, written);
917         }
918     }
919 
920     public static final class EmptyBootstrapAttribute
921             extends UnboundAttribute<BootstrapMethodsAttribute>
922             implements BootstrapMethodsAttribute {
923         public EmptyBootstrapAttribute() {
924             super(Attributes.BOOTSTRAP_METHODS);
925         }
926 
927         @Override
928         public int bootstrapMethodsSize() {
929             return 0;
930         }
931 
932         @Override
933         public List<BootstrapMethodEntry> bootstrapMethods() {
934             return List.of();
935         }
936     }
937 
938     public static abstract sealed class CustomAttribute<T extends CustomAttribute<T>>
939             extends UnboundAttribute<T>
940             permits jdk.internal.classfile.CustomAttribute {
941 
942         public CustomAttribute(AttributeMapper<T> mapper) {
943             super(mapper);
944         }
945     }
946 }