From 290eae52186f8c86ac04b69f9a96faefb507ee85 Mon Sep 17 00:00:00 2001 From: Egor Ushakov Date: Thu, 27 Sep 2018 15:37:20 +0300 Subject: [PATCH] cleanup: use typed attribute keys --- .../java/decompiler/main/ClassWriter.java | 38 ++++---- .../decompiler/main/ClassesProcessor.java | 9 +- .../main/collectors/ImportCollector.java | 11 +-- .../main/rels/NestedClassProcessor.java | 6 +- .../modules/decompiler/exps/ExitExprent.java | 7 +- .../java/decompiler/struct/StructMember.java | 15 ++-- .../java/decompiler/struct/StructMethod.java | 4 +- .../struct/attr/StructGeneralAttribute.java | 86 +++++++++++-------- .../decompiler/struct/lazy/LazyLoader.java | 4 +- 9 files changed, 93 insertions(+), 87 deletions(-) diff --git a/src/org/jetbrains/java/decompiler/main/ClassWriter.java b/src/org/jetbrains/java/decompiler/main/ClassWriter.java index 42ef5f4..216b914 100644 --- a/src/org/jetbrains/java/decompiler/main/ClassWriter.java +++ b/src/org/jetbrains/java/decompiler/main/ClassWriter.java @@ -274,8 +274,8 @@ public class ClassWriter { StructClass cl = wrapper.getClassStruct(); int flags = node.type == ClassNode.CLASS_ROOT ? cl.getAccessFlags() : node.access; - boolean isDeprecated = cl.hasAttribute("Deprecated"); - boolean isSynthetic = (flags & CodeConstants.ACC_SYNTHETIC) != 0 || cl.hasAttribute("Synthetic"); + boolean isDeprecated = cl.hasAttribute(StructGeneralAttribute.ATTRIBUTE_DEPRECATED); + boolean isSynthetic = (flags & CodeConstants.ACC_SYNTHETIC) != 0 || cl.hasAttribute(StructGeneralAttribute.ATTRIBUTE_SYNTHETIC); boolean isEnum = DecompilerContext.getOption(IFernflowerPreferences.DECOMPILE_ENUM) && (flags & CodeConstants.ACC_ENUM) != 0; boolean isInterface = (flags & CodeConstants.ACC_INTERFACE) != 0; boolean isAnnotation = (flags & CodeConstants.ACC_ANNOTATION) != 0; @@ -366,7 +366,7 @@ public class ClassWriter { private void fieldToJava(ClassWrapper wrapper, StructClass cl, StructField fd, TextBuffer buffer, int indent, BytecodeMappingTracer tracer) { int start = buffer.length(); boolean isInterface = cl.hasModifier(CodeConstants.ACC_INTERFACE); - boolean isDeprecated = fd.hasAttribute("Deprecated"); + boolean isDeprecated = fd.hasAttribute(StructGeneralAttribute.ATTRIBUTE_DEPRECATED); boolean isEnum = fd.hasModifier(CodeConstants.ACC_ENUM) && DecompilerContext.getOption(IFernflowerPreferences.DECOMPILE_ENUM); if (isDeprecated) { @@ -394,7 +394,7 @@ public class ClassWriter { GenericFieldDescriptor descriptor = null; if (DecompilerContext.getOption(IFernflowerPreferences.DECOMPILE_GENERIC_SIGNATURES)) { - StructGenericSignatureAttribute attr = (StructGenericSignatureAttribute)fd.getAttribute("Signature"); + StructGenericSignatureAttribute attr = fd.getAttribute(StructGeneralAttribute.ATTRIBUTE_SIGNATURE); if (attr != null) { descriptor = GenericMain.parseFieldSignature(attr.getSignature()); } @@ -580,7 +580,7 @@ public class ClassWriter { boolean isInterface = cl.hasModifier(CodeConstants.ACC_INTERFACE); boolean isAnnotation = cl.hasModifier(CodeConstants.ACC_ANNOTATION); boolean isEnum = cl.hasModifier(CodeConstants.ACC_ENUM) && DecompilerContext.getOption(IFernflowerPreferences.DECOMPILE_ENUM); - boolean isDeprecated = mt.hasAttribute("Deprecated"); + boolean isDeprecated = mt.hasAttribute(StructGeneralAttribute.ATTRIBUTE_DEPRECATED); boolean clinit = false, init = false, dinit = false; MethodDescriptor md = MethodDescriptor.parseDescriptor(mt.getDescriptor()); @@ -602,7 +602,7 @@ public class ClassWriter { appendRenameComment(buffer, oldName, MType.METHOD, indent); } - boolean isSynthetic = (flags & CodeConstants.ACC_SYNTHETIC) != 0 || mt.hasAttribute("Synthetic"); + boolean isSynthetic = (flags & CodeConstants.ACC_SYNTHETIC) != 0 || mt.hasAttribute(StructGeneralAttribute.ATTRIBUTE_SYNTHETIC); boolean isBridge = (flags & CodeConstants.ACC_BRIDGE) != 0; if (isSynthetic) { appendComment(buffer, "synthetic method", indent); @@ -640,7 +640,7 @@ public class ClassWriter { GenericMethodDescriptor descriptor = null; if (DecompilerContext.getOption(IFernflowerPreferences.DECOMPILE_GENERIC_SIGNATURES)) { - StructGenericSignatureAttribute attr = (StructGenericSignatureAttribute)mt.getAttribute("Signature"); + StructGenericSignatureAttribute attr = mt.getAttribute(StructGeneralAttribute.ATTRIBUTE_SIGNATURE); if (attr != null) { descriptor = GenericMain.parseMethodSignature(attr.getSignature()); if (descriptor != null) { @@ -768,7 +768,7 @@ public class ClassWriter { buffer.append(')'); - StructExceptionsAttribute attr = (StructExceptionsAttribute)mt.getAttribute("Exceptions"); + StructExceptionsAttribute attr = mt.getAttribute(StructGeneralAttribute.ATTRIBUTE_EXCEPTIONS); if ((descriptor != null && !descriptor.exceptionTypes.isEmpty()) || attr != null) { throwsExceptions = true; buffer.append(" throws "); @@ -793,7 +793,7 @@ public class ClassWriter { if ((flags & (CodeConstants.ACC_ABSTRACT | CodeConstants.ACC_NATIVE)) != 0) { // native or abstract method (explicit or interface) if (isAnnotation) { - StructAnnDefaultAttribute attr = (StructAnnDefaultAttribute)mt.getAttribute("AnnotationDefault"); + StructAnnDefaultAttribute attr = mt.getAttribute(StructGeneralAttribute.ATTRIBUTE_ANNOTATION_DEFAULT); if (attr != null) { buffer.append(" default "); buffer.append(attr.getDefaultValue().toJava(0, BytecodeMappingTracer.DUMMY)); @@ -946,18 +946,18 @@ public class ClassWriter { buffer.appendIndent(indent).append("// $FF: ").append(comment).appendLineSeparator(); } - private static final String[] ANNOTATION_ATTRIBUTES = { + private static final StructGeneralAttribute.Key[] ANNOTATION_ATTRIBUTES = { StructGeneralAttribute.ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS, StructGeneralAttribute.ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS}; - private static final String[] PARAMETER_ANNOTATION_ATTRIBUTES = { + private static final StructGeneralAttribute.Key[] PARAMETER_ANNOTATION_ATTRIBUTES = { StructGeneralAttribute.ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS, StructGeneralAttribute.ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS}; - private static final String[] TYPE_ANNOTATION_ATTRIBUTES = { + private static final StructGeneralAttribute.Key[] TYPE_ANNOTATION_ATTRIBUTES = { StructGeneralAttribute.ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS, StructGeneralAttribute.ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS}; private static void appendAnnotations(TextBuffer buffer, int indent, StructMember mb, int targetType) { Set filter = new HashSet<>(); - for (String name : ANNOTATION_ATTRIBUTES) { - StructAnnotationAttribute attribute = (StructAnnotationAttribute)mb.getAttribute(name); + for (StructGeneralAttribute.Key key : ANNOTATION_ATTRIBUTES) { + StructAnnotationAttribute attribute = (StructAnnotationAttribute)mb.getAttribute(key); if (attribute != null) { for (AnnotationExprent annotation : attribute.getAnnotations()) { String text = annotation.toJava(indent, BytecodeMappingTracer.DUMMY).toString(); @@ -973,8 +973,8 @@ public class ClassWriter { private static void appendParameterAnnotations(TextBuffer buffer, StructMethod mt, int param) { Set filter = new HashSet<>(); - for (String name : PARAMETER_ANNOTATION_ATTRIBUTES) { - StructAnnotationParameterAttribute attribute = (StructAnnotationParameterAttribute)mt.getAttribute(name); + for (StructGeneralAttribute.Key key : PARAMETER_ANNOTATION_ATTRIBUTES) { + StructAnnotationParameterAttribute attribute = (StructAnnotationParameterAttribute)mt.getAttribute(key); if (attribute != null) { List> annotations = attribute.getParamAnnotations(); if (param < annotations.size()) { @@ -991,8 +991,8 @@ public class ClassWriter { } private static void appendTypeAnnotations(TextBuffer buffer, int indent, StructMember mb, int targetType, int index, Set filter) { - for (String name : TYPE_ANNOTATION_ATTRIBUTES) { - StructTypeAnnotationAttribute attribute = (StructTypeAnnotationAttribute)mb.getAttribute(name); + for (StructGeneralAttribute.Key key : TYPE_ANNOTATION_ATTRIBUTES) { + StructTypeAnnotationAttribute attribute = (StructTypeAnnotationAttribute)mb.getAttribute(key); if (attribute != null) { for (TypeAnnotation annotation : attribute.getAnnotations()) { if (annotation.isTopLevel() && annotation.getTargetType() == targetType && (index < 0 || annotation.getIndex() == index)) { @@ -1057,7 +1057,7 @@ public class ClassWriter { public static GenericClassDescriptor getGenericClassDescriptor(StructClass cl) { if (DecompilerContext.getOption(IFernflowerPreferences.DECOMPILE_GENERIC_SIGNATURES)) { - StructGenericSignatureAttribute attr = (StructGenericSignatureAttribute)cl.getAttribute("Signature"); + StructGenericSignatureAttribute attr = cl.getAttribute(StructGeneralAttribute.ATTRIBUTE_SIGNATURE); if (attr != null) { return GenericMain.parseClassSignature(attr.getSignature()); } diff --git a/src/org/jetbrains/java/decompiler/main/ClassesProcessor.java b/src/org/jetbrains/java/decompiler/main/ClassesProcessor.java index 86b7194..49ccd49 100644 --- a/src/org/jetbrains/java/decompiler/main/ClassesProcessor.java +++ b/src/org/jetbrains/java/decompiler/main/ClassesProcessor.java @@ -1,6 +1,4 @@ -/* - * Copyright 2000-2017 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. - */ +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package org.jetbrains.java.decompiler.main; import org.jetbrains.java.decompiler.code.CodeConstants; @@ -18,6 +16,7 @@ import org.jetbrains.java.decompiler.modules.decompiler.vars.VarVersionPair; import org.jetbrains.java.decompiler.struct.StructClass; import org.jetbrains.java.decompiler.struct.StructContext; import org.jetbrains.java.decompiler.struct.StructMethod; +import org.jetbrains.java.decompiler.struct.attr.StructGeneralAttribute; import org.jetbrains.java.decompiler.struct.attr.StructInnerClassesAttribute; import org.jetbrains.java.decompiler.struct.gen.VarType; import org.jetbrains.java.decompiler.util.InterpreterUtil; @@ -59,7 +58,7 @@ public class ClassesProcessor { for (StructClass cl : context.getClasses().values()) { if (cl.isOwn() && !mapRootClasses.containsKey(cl.qualifiedName)) { if (bDecompileInner) { - StructInnerClassesAttribute inner = (StructInnerClassesAttribute)cl.getAttribute("InnerClasses"); + StructInnerClassesAttribute inner = cl.getAttribute(StructGeneralAttribute.ATTRIBUTE_INNER_CLASSES); if (inner != null) { for (StructInnerClassesAttribute.Entry entry : inner.getEntries()) { @@ -136,7 +135,7 @@ public class ClassesProcessor { Set setNestedClasses = mapNestedClassReferences.get(superClass); if (setNestedClasses != null) { StructClass scl = superNode.classStruct; - StructInnerClassesAttribute inner = (StructInnerClassesAttribute)scl.getAttribute("InnerClasses"); + StructInnerClassesAttribute inner = scl.getAttribute(StructGeneralAttribute.ATTRIBUTE_INNER_CLASSES); if (inner == null || inner.getEntries().isEmpty()) { DecompilerContext.getLogger().writeMessage(superClass + " does not contain inner classes!", IFernflowerLogger.Severity.WARN); diff --git a/src/org/jetbrains/java/decompiler/main/collectors/ImportCollector.java b/src/org/jetbrains/java/decompiler/main/collectors/ImportCollector.java index 16e5ad4..7b8c3b4 100644 --- a/src/org/jetbrains/java/decompiler/main/collectors/ImportCollector.java +++ b/src/org/jetbrains/java/decompiler/main/collectors/ImportCollector.java @@ -1,10 +1,9 @@ -/* - * Copyright 2000-2017 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. - */ +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package org.jetbrains.java.decompiler.main.collectors; import org.jetbrains.java.decompiler.main.ClassesProcessor.ClassNode; import org.jetbrains.java.decompiler.main.DecompilerContext; +import org.jetbrains.java.decompiler.struct.attr.StructGeneralAttribute; import org.jetbrains.java.decompiler.struct.attr.StructInnerClassesAttribute; import org.jetbrains.java.decompiler.util.TextBuffer; import org.jetbrains.java.decompiler.struct.StructClass; @@ -54,10 +53,8 @@ public class ImportCollector { } // .. all inner classes for the current class .. - if (currentClass.hasAttribute(StructInnerClassesAttribute.ATTRIBUTE_INNER_CLASSES)) { - StructInnerClassesAttribute attribute = - (StructInnerClassesAttribute)currentClass.getAttribute(StructInnerClassesAttribute.ATTRIBUTE_INNER_CLASSES); - + StructInnerClassesAttribute attribute = currentClass.getAttribute(StructGeneralAttribute.ATTRIBUTE_INNER_CLASSES); + if (attribute != null) { for (StructInnerClassesAttribute.Entry entry : attribute.getEntries()) { if (entry.enclosingName != null && entry.enclosingName.equals(currentClass.qualifiedName)) { setInnerClassNames.add(entry.simpleName); diff --git a/src/org/jetbrains/java/decompiler/main/rels/NestedClassProcessor.java b/src/org/jetbrains/java/decompiler/main/rels/NestedClassProcessor.java index b08d85c..b3e5710 100644 --- a/src/org/jetbrains/java/decompiler/main/rels/NestedClassProcessor.java +++ b/src/org/jetbrains/java/decompiler/main/rels/NestedClassProcessor.java @@ -1,4 +1,4 @@ -// Copyright 2000-2017 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package org.jetbrains.java.decompiler.main.rels; import org.jetbrains.java.decompiler.code.CodeConstants; @@ -20,6 +20,7 @@ import org.jetbrains.java.decompiler.struct.StructClass; import org.jetbrains.java.decompiler.struct.StructField; import org.jetbrains.java.decompiler.struct.StructMethod; import org.jetbrains.java.decompiler.struct.attr.StructEnclosingMethodAttribute; +import org.jetbrains.java.decompiler.struct.attr.StructGeneralAttribute; import org.jetbrains.java.decompiler.struct.gen.MethodDescriptor; import org.jetbrains.java.decompiler.struct.gen.VarType; import org.jetbrains.java.decompiler.util.InterpreterUtil; @@ -171,8 +172,7 @@ public class NestedClassProcessor { Set setEnclosing = child.enclosingClasses; if (!setEnclosing.isEmpty()) { - StructEnclosingMethodAttribute attr = - (StructEnclosingMethodAttribute)child.classStruct.getAttribute("EnclosingMethod"); + StructEnclosingMethodAttribute attr = child.classStruct.getAttribute(StructGeneralAttribute.ATTRIBUTE_ENCLOSING_METHOD); if (attr != null && attr.getMethodName() != null && node.classStruct.qualifiedName.equals(attr.getClassName()) && diff --git a/src/org/jetbrains/java/decompiler/modules/decompiler/exps/ExitExprent.java b/src/org/jetbrains/java/decompiler/modules/decompiler/exps/ExitExprent.java index 25506fa..b3cc07d 100644 --- a/src/org/jetbrains/java/decompiler/modules/decompiler/exps/ExitExprent.java +++ b/src/org/jetbrains/java/decompiler/modules/decompiler/exps/ExitExprent.java @@ -1,6 +1,4 @@ -/* - * Copyright 2000-2017 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. - */ +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package org.jetbrains.java.decompiler.modules.decompiler.exps; import org.jetbrains.java.decompiler.code.CodeConstants; @@ -11,6 +9,7 @@ import org.jetbrains.java.decompiler.main.rels.MethodWrapper; import org.jetbrains.java.decompiler.modules.decompiler.ExprProcessor; import org.jetbrains.java.decompiler.modules.decompiler.vars.CheckTypesResult; import org.jetbrains.java.decompiler.struct.attr.StructExceptionsAttribute; +import org.jetbrains.java.decompiler.struct.attr.StructGeneralAttribute; import org.jetbrains.java.decompiler.struct.gen.VarType; import org.jetbrains.java.decompiler.struct.match.MatchEngine; import org.jetbrains.java.decompiler.struct.match.MatchNode; @@ -84,7 +83,7 @@ public class ExitExprent extends Exprent { ClassNode node = ((ClassNode)DecompilerContext.getProperty(DecompilerContext.CURRENT_CLASS_NODE)); if (method != null && node != null) { - StructExceptionsAttribute attr = (StructExceptionsAttribute)method.methodStruct.getAttribute("Exceptions"); + StructExceptionsAttribute attr = method.methodStruct.getAttribute(StructGeneralAttribute.ATTRIBUTE_EXCEPTIONS); if (attr != null) { String classname = null; diff --git a/src/org/jetbrains/java/decompiler/struct/StructMember.java b/src/org/jetbrains/java/decompiler/struct/StructMember.java index 7a3afc4..a5b87f1 100644 --- a/src/org/jetbrains/java/decompiler/struct/StructMember.java +++ b/src/org/jetbrains/java/decompiler/struct/StructMember.java @@ -1,4 +1,4 @@ -// Copyright 2000-2017 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package org.jetbrains.java.decompiler.struct; import org.jetbrains.java.decompiler.code.CodeConstants; @@ -22,12 +22,13 @@ public class StructMember { return accessFlags; } - public StructGeneralAttribute getAttribute(String name) { - return attributes.get(name); + public T getAttribute(StructGeneralAttribute.Key attribute) { + //noinspection unchecked + return (T)attributes.get(attribute.getName()); } - public boolean hasAttribute(String name) { - return attributes.containsKey(name); + public boolean hasAttribute(StructGeneralAttribute.Key attribute) { + return attributes.containsKey(attribute.getName()); } public boolean hasModifier(int modifier) { @@ -49,12 +50,12 @@ public class StructMember { StructGeneralAttribute attribute = readAttribute(in, pool, name); if (attribute != null) { - if (StructGeneralAttribute.ATTRIBUTE_LOCAL_VARIABLE_TABLE.equals(name) && attributes.containsKey(name)) { + if (StructGeneralAttribute.ATTRIBUTE_LOCAL_VARIABLE_TABLE.getName().equals(name) && attributes.containsKey(name)) { // merge all variable tables StructLocalVariableTableAttribute table = (StructLocalVariableTableAttribute)attributes.get(name); table.add((StructLocalVariableTableAttribute)attribute); } - else if (StructGeneralAttribute.ATTRIBUTE_LOCAL_VARIABLE_TYPE_TABLE.equals(name) && attributes.containsKey(name)) { + else if (StructGeneralAttribute.ATTRIBUTE_LOCAL_VARIABLE_TYPE_TABLE.getName().equals(name) && attributes.containsKey(name)) { // merge all variable tables StructLocalVariableTypeTableAttribute table = (StructLocalVariableTypeTableAttribute)attributes.get(name); table.add((StructLocalVariableTypeTableAttribute)attribute); diff --git a/src/org/jetbrains/java/decompiler/struct/StructMethod.java b/src/org/jetbrains/java/decompiler/struct/StructMethod.java index 42003f3..ae6343d 100644 --- a/src/org/jetbrains/java/decompiler/struct/StructMethod.java +++ b/src/org/jetbrains/java/decompiler/struct/StructMethod.java @@ -1,4 +1,4 @@ -// Copyright 2000-2017 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package org.jetbrains.java.decompiler.struct; import org.jetbrains.java.decompiler.code.*; @@ -63,7 +63,7 @@ public class StructMethod extends StructMember { @Override protected StructGeneralAttribute readAttribute(DataInputFullStream in, ConstantPool pool, String name) throws IOException { - if (StructGeneralAttribute.ATTRIBUTE_CODE.equals(name)) { + if (StructGeneralAttribute.ATTRIBUTE_CODE.getName().equals(name)) { if (!classStruct.isOwn()) { // skip code in foreign classes in.discard(8); diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructGeneralAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructGeneralAttribute.java index eb69af4..f421671 100644 --- a/src/org/jetbrains/java/decompiler/struct/attr/StructGeneralAttribute.java +++ b/src/org/jetbrains/java/decompiler/struct/attr/StructGeneralAttribute.java @@ -1,6 +1,4 @@ -/* - * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. - */ +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package org.jetbrains.java.decompiler.struct.attr; import org.jetbrains.java.decompiler.struct.consts.ConstantPool; @@ -16,75 +14,87 @@ import java.io.IOException; } */ public class StructGeneralAttribute { - public static final String ATTRIBUTE_CODE = "Code"; - public static final String ATTRIBUTE_INNER_CLASSES = "InnerClasses"; - public static final String ATTRIBUTE_SIGNATURE = "Signature"; - public static final String ATTRIBUTE_ANNOTATION_DEFAULT = "AnnotationDefault"; - public static final String ATTRIBUTE_EXCEPTIONS = "Exceptions"; - public static final String ATTRIBUTE_ENCLOSING_METHOD = "EnclosingMethod"; - public static final String ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS = "RuntimeVisibleAnnotations"; - public static final String ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS = "RuntimeInvisibleAnnotations"; - public static final String ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS = "RuntimeVisibleParameterAnnotations"; - public static final String ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS = "RuntimeInvisibleParameterAnnotations"; - public static final String ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS = "RuntimeVisibleTypeAnnotations"; - public static final String ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS = "RuntimeInvisibleTypeAnnotations"; - public static final String ATTRIBUTE_LOCAL_VARIABLE_TABLE = "LocalVariableTable"; - public static final String ATTRIBUTE_LOCAL_VARIABLE_TYPE_TABLE = "LocalVariableTypeTable"; - public static final String ATTRIBUTE_CONSTANT_VALUE = "ConstantValue"; - public static final String ATTRIBUTE_BOOTSTRAP_METHODS = "BootstrapMethods"; - public static final String ATTRIBUTE_SYNTHETIC = "Synthetic"; - public static final String ATTRIBUTE_DEPRECATED = "Deprecated"; - public static final String ATTRIBUTE_LINE_NUMBER_TABLE = "LineNumberTable"; - public static final String ATTRIBUTE_METHOD_PARAMETERS = "MethodParameters"; + public static final Key ATTRIBUTE_CODE = new Key<>("Code"); + public static final Key ATTRIBUTE_INNER_CLASSES = new Key<>("InnerClasses"); + public static final Key ATTRIBUTE_SIGNATURE = new Key<>("Signature"); + public static final Key ATTRIBUTE_ANNOTATION_DEFAULT = new Key<>("AnnotationDefault"); + public static final Key ATTRIBUTE_EXCEPTIONS = new Key<>("Exceptions"); + public static final Key ATTRIBUTE_ENCLOSING_METHOD = new Key<>("EnclosingMethod"); + public static final Key ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS = new Key<>("RuntimeVisibleAnnotations"); + public static final Key ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS = new Key<>("RuntimeInvisibleAnnotations"); + public static final Key ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS = new Key<>("RuntimeVisibleParameterAnnotations"); + public static final Key ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS = new Key<>("RuntimeInvisibleParameterAnnotations"); + public static final Key ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS = new Key<>("RuntimeVisibleTypeAnnotations"); + public static final Key ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS = new Key<>("RuntimeInvisibleTypeAnnotations"); + public static final Key ATTRIBUTE_LOCAL_VARIABLE_TABLE = new Key<>("LocalVariableTable"); + public static final Key ATTRIBUTE_LOCAL_VARIABLE_TYPE_TABLE = new Key<>("LocalVariableTypeTable"); + public static final Key ATTRIBUTE_CONSTANT_VALUE = new Key<>("ConstantValue"); + public static final Key ATTRIBUTE_BOOTSTRAP_METHODS = new Key<>("BootstrapMethods"); + public static final Key ATTRIBUTE_SYNTHETIC = new Key<>("Synthetic"); + public static final Key ATTRIBUTE_DEPRECATED = new Key<>("Deprecated"); + public static final Key ATTRIBUTE_LINE_NUMBER_TABLE = new Key<>("LineNumberTable"); + public static final Key ATTRIBUTE_METHOD_PARAMETERS = new Key<>("MethodParameters"); + + public static class Key { + private final String name; + + public Key(String name) { + this.name = name; + } + + public String getName() { + return name; + } + } private String name; public static StructGeneralAttribute createAttribute(String name) { StructGeneralAttribute attr; - if (ATTRIBUTE_INNER_CLASSES.equals(name)) { + if (ATTRIBUTE_INNER_CLASSES.getName().equals(name)) { attr = new StructInnerClassesAttribute(); } - else if (ATTRIBUTE_CONSTANT_VALUE.equals(name)) { + else if (ATTRIBUTE_CONSTANT_VALUE.getName().equals(name)) { attr = new StructConstantValueAttribute(); } - else if (ATTRIBUTE_SIGNATURE.equals(name)) { + else if (ATTRIBUTE_SIGNATURE.getName().equals(name)) { attr = new StructGenericSignatureAttribute(); } - else if (ATTRIBUTE_ANNOTATION_DEFAULT.equals(name)) { + else if (ATTRIBUTE_ANNOTATION_DEFAULT.getName().equals(name)) { attr = new StructAnnDefaultAttribute(); } - else if (ATTRIBUTE_EXCEPTIONS.equals(name)) { + else if (ATTRIBUTE_EXCEPTIONS.getName().equals(name)) { attr = new StructExceptionsAttribute(); } - else if (ATTRIBUTE_ENCLOSING_METHOD.equals(name)) { + else if (ATTRIBUTE_ENCLOSING_METHOD.getName().equals(name)) { attr = new StructEnclosingMethodAttribute(); } - else if (ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS.equals(name) || ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS.equals(name)) { + else if (ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS.getName().equals(name) || ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS.getName().equals(name)) { attr = new StructAnnotationAttribute(); } - else if (ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS.equals(name) || ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS.equals(name)) { + else if (ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS.getName().equals(name) || ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS.getName().equals(name)) { attr = new StructAnnotationParameterAttribute(); } - else if (ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(name) || ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(name)) { + else if (ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS.getName().equals(name) || ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.getName().equals(name)) { attr = new StructTypeAnnotationAttribute(); } - else if (ATTRIBUTE_LOCAL_VARIABLE_TABLE.equals(name)) { + else if (ATTRIBUTE_LOCAL_VARIABLE_TABLE.getName().equals(name)) { attr = new StructLocalVariableTableAttribute(); } - else if (ATTRIBUTE_LOCAL_VARIABLE_TYPE_TABLE.equals(name)) { + else if (ATTRIBUTE_LOCAL_VARIABLE_TYPE_TABLE.getName().equals(name)) { attr = new StructLocalVariableTypeTableAttribute(); } - else if (ATTRIBUTE_BOOTSTRAP_METHODS.equals(name)) { + else if (ATTRIBUTE_BOOTSTRAP_METHODS.getName().equals(name)) { attr = new StructBootstrapMethodsAttribute(); } - else if (ATTRIBUTE_SYNTHETIC.equals(name) || ATTRIBUTE_DEPRECATED.equals(name)) { + else if (ATTRIBUTE_SYNTHETIC.getName().equals(name) || ATTRIBUTE_DEPRECATED.getName().equals(name)) { attr = new StructGeneralAttribute(); } - else if (ATTRIBUTE_LINE_NUMBER_TABLE.equals(name)) { + else if (ATTRIBUTE_LINE_NUMBER_TABLE.getName().equals(name)) { attr = new StructLineNumberTableAttribute(); } - else if (ATTRIBUTE_METHOD_PARAMETERS.equals(name)) { + else if (ATTRIBUTE_METHOD_PARAMETERS.getName().equals(name)) { attr = new StructMethodParametersAttribute(); } else { diff --git a/src/org/jetbrains/java/decompiler/struct/lazy/LazyLoader.java b/src/org/jetbrains/java/decompiler/struct/lazy/LazyLoader.java index abd24f9..63c0f8e 100644 --- a/src/org/jetbrains/java/decompiler/struct/lazy/LazyLoader.java +++ b/src/org/jetbrains/java/decompiler/struct/lazy/LazyLoader.java @@ -1,4 +1,4 @@ -// Copyright 2000-2017 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package org.jetbrains.java.decompiler.struct.lazy; import org.jetbrains.java.decompiler.main.extern.IBytecodeProvider; @@ -90,7 +90,7 @@ public class LazyLoader { for (int j = 0; j < attrSize; j++) { int attrNameIndex = in.readUnsignedShort(); String attrName = pool.getPrimitiveConstant(attrNameIndex).getString(); - if (!StructGeneralAttribute.ATTRIBUTE_CODE.equals(attrName)) { + if (!StructGeneralAttribute.ATTRIBUTE_CODE.getName().equals(attrName)) { in.discard(in.readInt()); continue; }