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