Uploaded image for project: 'JDK'
  1. JDK
  2. JDK-8331414

java.lang.classfile.Attributes class performs a lot of static initializations

    XMLWordPrintable

Details

    • CSR
    • Resolution: Approved
    • P4
    • 23
    • core-libs
    • None
    • source
    • minimal
    • Change in a preview API represents minimal compatibility risk.
    • Java API
    • SE

    Description

      Summary

      Reduce static initialization footprint of java.lang.classfile.Attributes.

      Problem

      java.lang.classfile.Attributes is a central point for AttributeMappers of all supported attributes. For each Attribute there is a relevant static final AttributeMapper field. Plus there is a field PREDEFINED_ATTRIBUTES initialized with a set of all mappers. Plus there is a static method standardAttribute(Utf8Entry name) providing mapping from Utf8Entry to a known AttributeMapper.

      These statically initialized fields and mapping represents enormous initialization footprint on the JDK critical bootstrap path.

      java.lang.classfile.Attributes is not declared final, even it is non-instantiable utility class.

      Solution

      Change all static final fields into static methods with lazy individual initialization of each AttributeMapper. Remove PREDEFINED_ATTRIBUTES field from the API. Remove standardAttribute(Utf8Entry name) static mapping method from the API. Declare java.lang.classfile.Attributes as final class.

      Specification

      src/java.base/share/classes/java/lang/classfile/Attributes.java

      - public class Attributes {
      -    /** Attribute mapper for the {@code AnnotationDefault} attribute */
      -    public static final AttributeMapper<AnnotationDefaultAttribute>
      -            ANNOTATION_DEFAULT = new AbstractAttributeMapper<>(NAME_ANNOTATION_DEFAULT) {
      -    /** Attribute mapper for the {@code BootstrapMethods} attribute */
      -    public static final AttributeMapper<BootstrapMethodsAttribute>
      -            BOOTSTRAP_METHODS = new AbstractAttributeMapper<>(NAME_BOOTSTRAP_METHODS) {
      -    /** Attribute mapper for the {@code CharacterRangeTable} attribute */
      -    public static final AttributeMapper<CharacterRangeTableAttribute>
      -            CHARACTER_RANGE_TABLE = new AbstractAttributeMapper<>(NAME_CHARACTER_RANGE_TABLE, true) {
      -    /** Attribute mapper for the {@code Code} attribute */
      -    public static final AttributeMapper<CodeAttribute>
      -            CODE = new AbstractAttributeMapper<>(NAME_CODE) {
      -    /** Attribute mapper for the {@code CompilationID} attribute */
      -    public static final AttributeMapper<CompilationIDAttribute>
      -            COMPILATION_ID = new AbstractAttributeMapper<>(NAME_COMPILATION_ID, true) {
      -    /** Attribute mapper for the {@code ConstantValue} attribute */
      -    public static final AttributeMapper<ConstantValueAttribute>
      -            CONSTANT_VALUE = new AbstractAttributeMapper<>(NAME_CONSTANT_VALUE) {
      -    /** Attribute mapper for the {@code Deprecated} attribute */
      -    public static final AttributeMapper<DeprecatedAttribute>
      -            DEPRECATED = new AbstractAttributeMapper<>(NAME_DEPRECATED, true) {
      -    /** Attribute mapper for the {@code EnclosingMethod} attribute */
      -    public static final AttributeMapper<EnclosingMethodAttribute>
      -            ENCLOSING_METHOD = new AbstractAttributeMapper<>(NAME_ENCLOSING_METHOD) {
      -    /** Attribute mapper for the {@code Exceptions} attribute */
      -    public static final AttributeMapper<ExceptionsAttribute>
      -            EXCEPTIONS = new AbstractAttributeMapper<>(NAME_EXCEPTIONS) {
      -    /** Attribute mapper for the {@code InnerClasses} attribute */
      -    public static final AttributeMapper<InnerClassesAttribute>
      -            INNER_CLASSES = new AbstractAttributeMapper<>(NAME_INNER_CLASSES) {
      -    /** Attribute mapper for the {@code LineNumberTable} attribute */
      -    public static final AttributeMapper<LineNumberTableAttribute>
      -            LINE_NUMBER_TABLE = new AbstractAttributeMapper<>(NAME_LINE_NUMBER_TABLE, true) {
      -    /** Attribute mapper for the {@code LocalVariableTable} attribute */
      -    public static final AttributeMapper<LocalVariableTableAttribute>
      -            LOCAL_VARIABLE_TABLE = new AbstractAttributeMapper<>(NAME_LOCAL_VARIABLE_TABLE, true) {
      -    /** Attribute mapper for the {@code LocalVariableTypeTable} attribute */
      -    public static final AttributeMapper<LocalVariableTypeTableAttribute>
      -            LOCAL_VARIABLE_TYPE_TABLE = new AbstractAttributeMapper<>(NAME_LOCAL_VARIABLE_TYPE_TABLE, true) {
      -    /** Attribute mapper for the {@code MethodParameters} attribute */
      -    public static final AttributeMapper<MethodParametersAttribute>
      -            METHOD_PARAMETERS = new AbstractAttributeMapper<>(NAME_METHOD_PARAMETERS) {
      -    /** Attribute mapper for the {@code Module} attribute */
      -    public static final AttributeMapper<ModuleAttribute>
      -            MODULE = new AbstractAttributeMapper<>(NAME_MODULE) {
      -    /** Attribute mapper for the {@code ModuleHashes} attribute */
      -    public static final AttributeMapper<ModuleHashesAttribute>
      -            MODULE_HASHES = new AbstractAttributeMapper<>(NAME_MODULE_HASHES) {
      -    /** Attribute mapper for the {@code ModuleMainClass} attribute */
      -    public static final AttributeMapper<ModuleMainClassAttribute>
      -            MODULE_MAIN_CLASS = new AbstractAttributeMapper<>(NAME_MODULE_MAIN_CLASS) {
      -    /** Attribute mapper for the {@code ModulePackages} attribute */
      -    public static final AttributeMapper<ModulePackagesAttribute>
      -            MODULE_PACKAGES = new AbstractAttributeMapper<>(NAME_MODULE_PACKAGES) {
      -    /** Attribute mapper for the {@code ModuleResolution} attribute */
      -    public static final AttributeMapper<ModuleResolutionAttribute>
      -            MODULE_RESOLUTION = new AbstractAttributeMapper<>(NAME_MODULE_RESOLUTION) {
      -    /** Attribute mapper for the {@code ModuleTarget} attribute */
      -    public static final AttributeMapper<ModuleTargetAttribute>
      -            MODULE_TARGET = new AbstractAttributeMapper<>(NAME_MODULE_TARGET) {
      -    /** Attribute mapper for the {@code NestHost} attribute */
      -    public static final AttributeMapper<NestHostAttribute>
      -            NEST_HOST = new AbstractAttributeMapper<>(NAME_NEST_HOST) {
      -    /** Attribute mapper for the {@code NestMembers} attribute */
      -    public static final AttributeMapper<NestMembersAttribute>
      -            NEST_MEMBERS = new AbstractAttributeMapper<>(NAME_NEST_MEMBERS) {
      -    /** Attribute mapper for the {@code PermittedSubclasses} attribute */
      -    public static final AttributeMapper<PermittedSubclassesAttribute>
      -            PERMITTED_SUBCLASSES = new AbstractAttributeMapper<>(NAME_PERMITTED_SUBCLASSES) {
      -    /** Attribute mapper for the {@code Record} attribute */
      -    public static final AttributeMapper<RecordAttribute>
      -            RECORD = new AbstractAttributeMapper<>(NAME_RECORD) {
      -    /** Attribute mapper for the {@code RuntimeInvisibleAnnotations} attribute */
      -    public static final AttributeMapper<RuntimeInvisibleAnnotationsAttribute>
      -            RUNTIME_INVISIBLE_ANNOTATIONS = new AbstractAttributeMapper<>(NAME_RUNTIME_INVISIBLE_ANNOTATIONS) {
      -    /** Attribute mapper for the {@code RuntimeInvisibleParameterAnnotations} attribute */
      -    public static final AttributeMapper<RuntimeInvisibleParameterAnnotationsAttribute>
      -            RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS = new AbstractAttributeMapper<>(NAME_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS) {
      -    /** Attribute mapper for the {@code RuntimeInvisibleTypeAnnotations} attribute */
      -    public static final AttributeMapper<RuntimeInvisibleTypeAnnotationsAttribute>
      -            RUNTIME_INVISIBLE_TYPE_ANNOTATIONS = new AbstractAttributeMapper<>(NAME_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS) {
      -    /** Attribute mapper for the {@code RuntimeVisibleAnnotations} attribute */
      -    public static final AttributeMapper<RuntimeVisibleAnnotationsAttribute>
      -            RUNTIME_VISIBLE_ANNOTATIONS = new AbstractAttributeMapper<>(NAME_RUNTIME_VISIBLE_ANNOTATIONS) {
      -    /** Attribute mapper for the {@code RuntimeVisibleParameterAnnotations} attribute */
      -    public static final AttributeMapper<RuntimeVisibleParameterAnnotationsAttribute>
      -            RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS = new AbstractAttributeMapper<>(NAME_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS) {
      -    /** Attribute mapper for the {@code RuntimeVisibleTypeAnnotations} attribute */
      -    public static final AttributeMapper<RuntimeVisibleTypeAnnotationsAttribute>
      -            RUNTIME_VISIBLE_TYPE_ANNOTATIONS = new AbstractAttributeMapper<>(NAME_RUNTIME_VISIBLE_TYPE_ANNOTATIONS) {
      -    /** Attribute mapper for the {@code Signature} attribute */
      -    public static final AttributeMapper<SignatureAttribute>
      -            SIGNATURE = new AbstractAttributeMapper<>(NAME_SIGNATURE) {
      -    /** Attribute mapper for the {@code SourceDebugExtension} attribute */
      -    public static final AttributeMapper<SourceDebugExtensionAttribute>
      -            SOURCE_DEBUG_EXTENSION = new AbstractAttributeMapper<>(NAME_SOURCE_DEBUG_EXTENSION) {
      -    /** Attribute mapper for the {@code SourceFile} attribute */
      -    public static final AttributeMapper<SourceFileAttribute>
      -            SOURCE_FILE = new AbstractAttributeMapper<>(NAME_SOURCE_FILE) {
      -    /** Attribute mapper for the {@code SourceID} attribute */
      -    public static final AttributeMapper<SourceIDAttribute>
      -            SOURCE_ID = new AbstractAttributeMapper<>(NAME_SOURCE_ID) {
      -    /** Attribute mapper for the {@code StackMapTable} attribute */
      -    public static final AttributeMapper<StackMapTableAttribute>
      -            STACK_MAP_TABLE = new AbstractAttributeMapper<>(NAME_STACK_MAP_TABLE) {
      -    /** Attribute mapper for the {@code Synthetic} attribute */
      -    public static final AttributeMapper<SyntheticAttribute>
      -            SYNTHETIC = new AbstractAttributeMapper<>(NAME_SYNTHETIC, true) {
      -   /**
      -     * All standard attribute mappers.
      -     */
      -    public static final Set<AttributeMapper<?>> PREDEFINED_ATTRIBUTES = Set.of(
      -            ANNOTATION_DEFAULT,
      -            BOOTSTRAP_METHODS,
      -            CHARACTER_RANGE_TABLE,
      -            CODE,
      -            COMPILATION_ID,
      -            CONSTANT_VALUE,
      -            DEPRECATED,
      -            ENCLOSING_METHOD,
      -            EXCEPTIONS,
      -            INNER_CLASSES,
      -            LINE_NUMBER_TABLE,
      -            LOCAL_VARIABLE_TABLE,
      -            LOCAL_VARIABLE_TYPE_TABLE,
      -            METHOD_PARAMETERS,
      -            MODULE,
      -            MODULE_HASHES,
      -            MODULE_MAIN_CLASS,
      -            MODULE_PACKAGES,
      -            MODULE_RESOLUTION,
      -            MODULE_TARGET,
      -            NEST_HOST,
      -            NEST_MEMBERS,
      -            PERMITTED_SUBCLASSES,
      -            RECORD,
      -            RUNTIME_INVISIBLE_ANNOTATIONS,
      -            RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS,
      -            RUNTIME_INVISIBLE_TYPE_ANNOTATIONS,
      -            RUNTIME_VISIBLE_ANNOTATIONS,
      -            RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS,
      -            RUNTIME_VISIBLE_TYPE_ANNOTATIONS,
      -            SIGNATURE,
      -            SOURCE_DEBUG_EXTENSION,
      -            SOURCE_FILE,
      -            SOURCE_ID,
      -            STACK_MAP_TABLE,
      -            SYNTHETIC);
       /**
        * Attribute mappers for standard classfile attributes.
      + * <p>
      + * Unless otherwise specified, mappers returned by each method
      + * do not permit multiple attribute instances in a given location.
      + * <p>
      + * The most stable {@link AttributeStability#STATELESS STATELESS} mappers are:
      + * <ul>
      + * <li>{@link #deprecated()}
      + * <li>{@link #moduleResolution()}
      + * <li>{@link #sourceDebugExtension()}
      + * <li>{@link #synthetic()}
      + * </ul>
      + *
      + * The mappers with {@link AttributeStability#CP_REFS CP_REFS} stability are:
      + * <ul>
      + * <li>{@link #annotationDefault()}
      + * <li>{@link #bootstrapMethods()}
      + * <li>{@link #code()}
      + * <li>{@link #compilationId()}
      + * <li>{@link #constantValue()}
      + * <li>{@link #enclosingMethod()}
      + * <li>{@link #exceptions()}
      + * <li>{@link #innerClasses()}
      + * <li>{@link #methodParameters()}
      + * <li>{@link #module()}
      + * <li>{@link #moduleHashes()}
      + * <li>{@link #moduleMainClass()}
      + * <li>{@link #modulePackages()}
      + * <li>{@link #moduleTarget()}
      + * <li>{@link #nestHost()}
      + * <li>{@link #nestMembers()}
      + * <li>{@link #permittedSubclasses()}
      + * <li>{@link #record()}
      + * <li>{@link #runtimeInvisibleAnnotations()}
      + * <li>{@link #runtimeInvisibleParameterAnnotations()}
      + * <li>{@link #runtimeVisibleAnnotations()}
      + * <li>{@link #runtimeVisibleParameterAnnotations()}
      + * <li>{@link #signature()}
      + * <li>{@link #sourceFile()}
      + * <li>{@link #sourceId()}
      + * </ul>
      + *
      + * The mappers with {@link AttributeStability#LABELS LABELS} stability are:
      + * <ul>
      + * <li>{@link #characterRangeTable()}
      + * <li>{@link #lineNumberTable()}
      + * <li>{@link #localVariableTable()}
      + * <li>{@link #localVariableTypeTable()}
      + * </ul>
      + *
      + * The {@link AttributeStability#UNSTABLE UNSTABLE} mappers are:
      + * <ul>
      + * <li>{@link #runtimeInvisibleTypeAnnotations()}
      + * <li>{@link #runtimeVisibleTypeAnnotations()}
      + * </ul>
        *
        * @see AttributeMapper
        *
        * @since 22
        */
       @PreviewFeature(feature = PreviewFeature.Feature.CLASSFILE_API)
      + public final class Attributes {
      +
      +    /**
      +     * {@return Attribute mapper for the {@code AnnotationDefault} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<AnnotationDefaultAttribute> annotationDefault() {
      +        return AnnotationDefaultMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code BootstrapMethods} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<BootstrapMethodsAttribute> bootstrapMethods() {
      +        return BootstrapMethodsMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code CharacterRangeTable} attribute}
      +     * The mapper permits multiple instances in a given location.
      +     * @since 23
      +     */
      +    public static AttributeMapper<CharacterRangeTableAttribute> characterRangeTable() {
      +        return CharacterRangeTableMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code Code} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<CodeAttribute> code() {
      +        return CodeMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code CompilationID} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<CompilationIDAttribute> compilationId() {
      +        return CompilationIDMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code ConstantValue} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<ConstantValueAttribute> constantValue() {
      +        return ConstantValueMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code Deprecated} attribute}
      +     * The mapper permits multiple instances in a given location.
      +     * @since 23
      +     */
      +    public static AttributeMapper<DeprecatedAttribute> deprecated() {
      +        return DeprecatedMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code EnclosingMethod} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<EnclosingMethodAttribute> enclosingMethod() {
      +        return EnclosingMethodMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code Exceptions} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<ExceptionsAttribute> exceptions() {
      +        return ExceptionsMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code InnerClasses} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<InnerClassesAttribute> innerClasses() {
      +        return InnerClassesMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code LineNumberTable} attribute}
      +     * The mapper permits multiple instances in a given location.
      +     * @since 23
      +     */
      +    public static AttributeMapper<LineNumberTableAttribute> lineNumberTable() {
      +        return LineNumberTableMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code LocalVariableTable} attribute}
      +     * The mapper permits multiple instances in a given location.
      +     * @since 23
      +     */
      +    public static AttributeMapper<LocalVariableTableAttribute> localVariableTable() {
      +        return LocalVariableTableMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code LocalVariableTypeTable} attribute}
      +     * The mapper permits multiple instances in a given location.
      +     * @since 23
      +     */
      +    public static AttributeMapper<LocalVariableTypeTableAttribute> localVariableTypeTable() {
      +        return LocalVariableTypeTableMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code MethodParameters} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<MethodParametersAttribute> methodParameters() {
      +        return MethodParametersMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code Module} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<ModuleAttribute> module() {
      +        return ModuleMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code ModuleHashes} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<ModuleHashesAttribute> moduleHashes() {
      +        return ModuleHashesMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code ModuleMainClass} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<ModuleMainClassAttribute> moduleMainClass() {
      +        return ModuleMainClassMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code ModulePackages} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<ModulePackagesAttribute> modulePackages() {
      +        return ModulePackagesMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code ModuleResolution} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<ModuleResolutionAttribute> moduleResolution() {
      +        return ModuleResolutionMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code ModuleTarget} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<ModuleTargetAttribute> moduleTarget() {
      +        return ModuleTargetMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code NestHost} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<NestHostAttribute> nestHost() {
      +        return NestHostMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code NestMembers} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<NestMembersAttribute> nestMembers() {
      +        return NestMembersMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code PermittedSubclasses} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<PermittedSubclassesAttribute> permittedSubclasses() {
      +        return PermittedSubclassesMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code Record} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<RecordAttribute> record() {
      +        return RecordMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code RuntimeInvisibleAnnotations} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<RuntimeInvisibleAnnotationsAttribute> runtimeInvisibleAnnotations() {
      +        return RuntimeInvisibleAnnotationsMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code RuntimeInvisibleParameterAnnotations} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<RuntimeInvisibleParameterAnnotationsAttribute> runtimeInvisibleParameterAnnotations() {
      +        return RuntimeInvisibleParameterAnnotationsMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code RuntimeInvisibleTypeAnnotations} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<RuntimeInvisibleTypeAnnotationsAttribute> runtimeInvisibleTypeAnnotations() {
      +        return RuntimeInvisibleTypeAnnotationsMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code RuntimeVisibleAnnotations} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<RuntimeVisibleAnnotationsAttribute> runtimeVisibleAnnotations() {
      +        return RuntimeVisibleAnnotationsMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code RuntimeVisibleParameterAnnotations} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<RuntimeVisibleParameterAnnotationsAttribute> runtimeVisibleParameterAnnotations() {
      +        return RuntimeVisibleParameterAnnotationsMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code RuntimeVisibleTypeAnnotations} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<RuntimeVisibleTypeAnnotationsAttribute> runtimeVisibleTypeAnnotations() {
      +        return RuntimeVisibleTypeAnnotationsMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code Signature} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<SignatureAttribute> signature() {
      +        return SignatureMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code SourceDebugExtension} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<SourceDebugExtensionAttribute> sourceDebugExtension() {
      +        return SourceDebugExtensionMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code SourceFile} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<SourceFileAttribute> sourceFile() {
      +        return SourceFileMapper.INSTANCE;
      +    }
      +
      +    /**
      +     * {@return Attribute mapper for the {@code SourceID} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<SourceIDAttribute> sourceId() {
      +        return SourceIDMapper.INSTANCE;
      +    }
      + 
      +    /**
      +     * {@return Attribute mapper for the {@code StackMapTable} attribute}
      +     * @since 23
      +     */
      +    public static AttributeMapper<StackMapTableAttribute> stackMapTable() {
      +        return StackMapTableMapper.INSTANCE;
      +    }
      + 
      +    /**
      +     * {@return Attribute mapper for the {@code Synthetic} attribute}
      +     * The mapper permits multiple instances in a given location.
      +     * @since 23
      +     */
      +    public static AttributeMapper<SyntheticAttribute> synthetic() {
      +        return SyntheticMapper.INSTANCE;
      +    }
      

      Attachments

        Issue Links

          Activity

            People

              asotona Adam Sotona
              asotona Adam Sotona
              Vicente Arturo Romero Zaldivar
              Votes:
              2 Vote for this issue
              Watchers:
              3 Start watching this issue

              Dates

                Created:
                Updated:
                Resolved: