openrs2
/
fernflower
1
0
Fork 0
Code Issues 9 Pull Requests Releases Activity

[java, java-decompiler] type annotations in class files

Browse Source 
Step 1: add top-level field/method/parameter annotations to stubs; include them in decompiled text.
master
Roman Shevchenko 9 years ago
parent a8403429ef
commit 52b31bf325
13 changed files with 315 additions and 240 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 65
      src/org/jetbrains/java/decompiler/main/ClassWriter.java
  2. 29
      src/org/jetbrains/java/decompiler/modules/decompiler/exps/AnnotationExprent.java
  3. 67
      src/org/jetbrains/java/decompiler/modules/decompiler/exps/TypeAnnotation.java
  4. 5
      src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationAttribute.java
  5. 194
      src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationTypeAttribute.java
  6. 17
      src/org/jetbrains/java/decompiler/struct/attr/StructGeneralAttribute.java
  7. 107
      src/org/jetbrains/java/decompiler/struct/attr/StructTypeAnnotationAttribute.java
  8. 1
      test/org/jetbrains/java/decompiler/SingleClassesTest.java
  9. BIN
      testData/classes/pkg/TypeAnnotations$MixA.class
  10. BIN
      testData/classes/pkg/TypeAnnotations$TA.class
  11. BIN
      testData/classes/pkg/TypeAnnotations.class
  12. 44
      testData/results/TypeAnnotations.dec
  13. 22
      testData/src/pkg/TypeAnnotations.java

65
src/org/jetbrains/java/decompiler/main/ClassWriter.java
Unescape View File

@ -23,10 +23,7 @@ import org.jetbrains.java.decompiler.main.extern.IFernflowerPreferences;
import org.jetbrains.java.decompiler.main.rels.ClassWrapper; import org.jetbrains.java.decompiler.main.rels.ClassWrapper;
import org.jetbrains.java.decompiler.main.rels.MethodWrapper; import org.jetbrains.java.decompiler.main.rels.MethodWrapper;
import org.jetbrains.java.decompiler.modules.decompiler.ExprProcessor; import org.jetbrains.java.decompiler.modules.decompiler.ExprProcessor;
import org.jetbrains.java.decompiler.modules.decompiler.exps.AnnotationExprent; import org.jetbrains.java.decompiler.modules.decompiler.exps.*;
import org.jetbrains.java.decompiler.modules.decompiler.exps.ConstExprent;
import org.jetbrains.java.decompiler.modules.decompiler.exps.Exprent;
import org.jetbrains.java.decompiler.modules.decompiler.exps.NewExprent;
import org.jetbrains.java.decompiler.modules.decompiler.stats.RootStatement; import org.jetbrains.java.decompiler.modules.decompiler.stats.RootStatement;
import org.jetbrains.java.decompiler.modules.decompiler.vars.VarTypeProcessor; import org.jetbrains.java.decompiler.modules.decompiler.vars.VarTypeProcessor;
import org.jetbrains.java.decompiler.modules.decompiler.vars.VarVersionPair; import org.jetbrains.java.decompiler.modules.decompiler.vars.VarVersionPair;
@ -43,9 +40,7 @@ import org.jetbrains.java.decompiler.struct.gen.VarType;
import org.jetbrains.java.decompiler.struct.gen.generics.*; import org.jetbrains.java.decompiler.struct.gen.generics.*;
import org.jetbrains.java.decompiler.util.InterpreterUtil; import org.jetbrains.java.decompiler.util.InterpreterUtil;
import java.util.LinkedHashMap; import java.util.*;
import java.util.List;
import java.util.Map;
public class ClassWriter { public class ClassWriter {
private final PoolInterceptor interceptor; private final PoolInterceptor interceptor;
@ -311,7 +306,7 @@ public class ClassWriter {
appendComment(buffer, "synthetic class", indent); appendComment(buffer, "synthetic class", indent);
} }
appendAnnotations(buffer, cl, indent); appendAnnotations(buffer, indent, cl, -1);
buffer.appendIndent(indent); buffer.appendIndent(indent);
@ -407,7 +402,7 @@ public class ClassWriter {
appendComment(buffer, "synthetic field", indent); appendComment(buffer, "synthetic field", indent);
} }
appendAnnotations(buffer, fd, indent); appendAnnotations(buffer, indent, fd, TypeAnnotation.FIELD);
buffer.appendIndent(indent); buffer.appendIndent(indent);
@ -630,7 +625,7 @@ public class ClassWriter {
appendComment(buffer, "bridge method", indent); appendComment(buffer, "bridge method", indent);
} }
appendAnnotations(buffer, mt, indent); appendAnnotations(buffer, indent, mt, TypeAnnotation.METHOD_RETURN_TYPE);
buffer.appendIndent(indent); buffer.appendIndent(indent);
@ -816,7 +811,7 @@ public class ClassWriter {
StructAnnDefaultAttribute attr = (StructAnnDefaultAttribute)mt.getAttributes().getWithKey("AnnotationDefault"); StructAnnDefaultAttribute attr = (StructAnnDefaultAttribute)mt.getAttributes().getWithKey("AnnotationDefault");
if (attr != null) { if (attr != null) {
buffer.append(" default "); buffer.append(" default ");
buffer.append(attr.getDefaultValue().toJava(0, new BytecodeMappingTracer())); // dummy tracer buffer.append(attr.getDefaultValue().toJava(0, BytecodeMappingTracer.DUMMY));
} }
} }
@ -951,26 +946,30 @@ public class ClassWriter {
private static final String[] ANNOTATION_ATTRIBUTES = { private static final String[] ANNOTATION_ATTRIBUTES = {
StructGeneralAttribute.ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS, StructGeneralAttribute.ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS}; StructGeneralAttribute.ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS, StructGeneralAttribute.ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS};
private static final String[] PARAMETER_ANNOTATION_ATTRIBUTES = {
StructGeneralAttribute.ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS, StructGeneralAttribute.ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS};
private static final String[] TYPE_ANNOTATION_ATTRIBUTES = {
StructGeneralAttribute.ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS, StructGeneralAttribute.ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS};
private static void appendAnnotations(TextBuffer buffer, StructMember mb, int indent) { private static void appendAnnotations(TextBuffer buffer, int indent, StructMember mb, int targetType) {
BytecodeMappingTracer tracer_dummy = new BytecodeMappingTracer(); // FIXME: replace with a real one Set<String> filter = new HashSet<>();
for (String name : ANNOTATION_ATTRIBUTES) { for (String name : ANNOTATION_ATTRIBUTES) {
StructAnnotationAttribute attribute = (StructAnnotationAttribute)mb.getAttributes().getWithKey(name); StructAnnotationAttribute attribute = (StructAnnotationAttribute)mb.getAttributes().getWithKey(name);
if (attribute != null) { if (attribute != null) {
for (AnnotationExprent annotation : attribute.getAnnotations()) { for (AnnotationExprent annotation : attribute.getAnnotations()) {
buffer.append(annotation.toJava(indent, tracer_dummy)).appendLineSeparator(); String text = annotation.toJava(indent, BytecodeMappingTracer.DUMMY).toString();
filter.add(text);
buffer.append(text).appendLineSeparator();
} }
} }
} }
}
private static final String[] PARAMETER_ANNOTATION_ATTRIBUTES = { appendTypeAnnotations(buffer, indent, mb, targetType, -1, filter);
StructGeneralAttribute.ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS, }
StructGeneralAttribute.ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS};
private static void appendParameterAnnotations(TextBuffer buffer, StructMethod mt, int param) { private static void appendParameterAnnotations(TextBuffer buffer, StructMethod mt, int param) {
BytecodeMappingTracer tracer_dummy = new BytecodeMappingTracer(); // FIXME: replace with a real one Set<String> filter = new HashSet<>();
for (String name : PARAMETER_ANNOTATION_ATTRIBUTES) { for (String name : PARAMETER_ANNOTATION_ATTRIBUTES) {
StructAnnotationParameterAttribute attribute = (StructAnnotationParameterAttribute)mt.getAttributes().getWithKey(name); StructAnnotationParameterAttribute attribute = (StructAnnotationParameterAttribute)mt.getAttributes().getWithKey(name);
@ -978,7 +977,33 @@ public class ClassWriter {
List<List<AnnotationExprent>> annotations = attribute.getParamAnnotations(); List<List<AnnotationExprent>> annotations = attribute.getParamAnnotations();
if (param < annotations.size()) { if (param < annotations.size()) {
for (AnnotationExprent annotation : annotations.get(param)) { for (AnnotationExprent annotation : annotations.get(param)) {
buffer.append(annotation.toJava(0, tracer_dummy)).append(' '); String text = annotation.toJava(-1, BytecodeMappingTracer.DUMMY).toString();
filter.add(text);
buffer.append(text).append(' ');
}
}
}
}
appendTypeAnnotations(buffer, -1, mt, TypeAnnotation.METHOD_PARAMETER, param, filter);
}
private static void appendTypeAnnotations(TextBuffer buffer, int indent, StructMember mb, int targetType, int index, Set<String> filter) {
for (String name : TYPE_ANNOTATION_ATTRIBUTES) {
StructTypeAnnotationAttribute attribute = (StructTypeAnnotationAttribute)mb.getAttributes().getWithKey(name);
if (attribute != null) {
for (TypeAnnotation annotation : attribute.getAnnotations()) {
if (annotation.isTopLevel() && annotation.getTargetType() == targetType && (index < 0 || annotation.getIndex() == index)) {
String text = annotation.getAnnotation().toJava(indent, BytecodeMappingTracer.DUMMY).toString();
if (!filter.contains(text)) {
buffer.append(text);
if (indent < 0) {
buffer.append(' ');
}
else {
buffer.appendLineSeparator();
}
}
} }
} }
} }

29
src/org/jetbrains/java/decompiler/modules/decompiler/exps/AnnotationExprent.java
Unescape View File

@ -47,22 +47,31 @@ public class AnnotationExprent extends Exprent {
buffer.append('@'); buffer.append('@');
buffer.append(DecompilerContext.getImportCollector().getShortName(ExprProcessor.buildJavaClassName(className))); buffer.append(DecompilerContext.getImportCollector().getShortName(ExprProcessor.buildJavaClassName(className)));
if (!parNames.isEmpty()) { int type = getAnnotationType();
if (type != ANNOTATION_MARKER) {
buffer.append('('); buffer.append('(');
if (getAnnotationType() == ANNOTATION_SINGLE_ELEMENT) {
buffer.append(parValues.get(0).toJava(indent + 1, tracer)); boolean oneLiner = type == ANNOTATION_SINGLE_ELEMENT || indent < 0;
}
else { for (int i = 0; i < parNames.size(); i++) {
for (int i = 0; i < parNames.size(); i++) { if (!oneLiner) {
buffer.appendLineSeparator().appendIndent(indent + 1); buffer.appendLineSeparator().appendIndent(indent + 1);
}
if (type != ANNOTATION_SINGLE_ELEMENT) {
buffer.append(parNames.get(i)); buffer.append(parNames.get(i));
buffer.append(" = "); buffer.append(" = ");
buffer.append(parValues.get(i).toJava(0, tracer)); }
buffer.append(parValues.get(i).toJava(0, tracer));
if (i < parNames.size() - 1) { if (i < parNames.size() - 1) {
buffer.append(','); buffer.append(',');
}
} }
}
if (!oneLiner) {
buffer.appendLineSeparator().appendIndent(indent); buffer.appendLineSeparator().appendIndent(indent);
} }

67
src/org/jetbrains/java/decompiler/modules/decompiler/exps/TypeAnnotation.java
Unescape View File

@ -0,0 +1,67 @@
/*
* Copyright 2000-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.java.decompiler.modules.decompiler.exps;
public class TypeAnnotation {
public static final int CLASS_TYPE_PARAMETER = 0x00;
public static final int METHOD_TYPE_PARAMETER = 0x01;
public static final int SUPER_TYPE_REFERENCE = 0x10;
public static final int CLASS_TYPE_PARAMETER_BOUND = 0x11;
public static final int METHOD_TYPE_PARAMETER_BOUND = 0x12;
public static final int FIELD = 0x13;
public static final int METHOD_RETURN_TYPE = 0x14;
public static final int METHOD_RECEIVER = 0x15;
public static final int METHOD_PARAMETER = 0x16;
public static final int THROWS_REFERENCE = 0x17;
public static final int LOCAL_VARIABLE = 0x40;
public static final int RESOURCE_VARIABLE = 0x41;
public static final int CATCH_CLAUSE = 0x42;
public static final int EXPR_INSTANCEOF = 0x43;
public static final int EXPR_NEW = 0x44;
public static final int EXPR_CONSTRUCTOR_REF = 0x45;
public static final int EXPR_METHOD_REF = 0x46;
public static final int TYPE_ARG_CAST = 0x47;
public static final int TYPE_ARG_CONSTRUCTOR_CALL = 0x48;
public static final int TYPE_ARG_METHOD_CALL = 0x49;
public static final int TYPE_ARG_CONSTRUCTOR_REF = 0x4A;
public static final int TYPE_ARG_METHOD_REF = 0x4B;
private final int target;
private final byte[] path;
private final AnnotationExprent annotation;
public TypeAnnotation(int target, byte[] path, AnnotationExprent annotation) {
this.target = target;
this.path = path;
this.annotation = annotation;
}
public int getTargetType() {
return target >> 24;
}
public int getIndex() {
return target & 0x0FFFF;
}
public boolean isTopLevel() {
return path == null;
}
public AnnotationExprent getAnnotation() {
return annotation;
}
}

5
src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationAttribute.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2000-2014 JetBrains s.r.o. * Copyright 2000-2016 JetBrains s.r.o.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -29,7 +29,6 @@ import java.util.Collections;
import java.util.List; import java.util.List;
public class StructAnnotationAttribute extends StructGeneralAttribute { public class StructAnnotationAttribute extends StructGeneralAttribute {
private List<AnnotationExprent> annotations; private List<AnnotationExprent> annotations;
@Override @Override
@ -143,7 +142,7 @@ public class StructAnnotationAttribute extends StructGeneralAttribute {
newType = new VarType(elementType.type, 1, elementType.value); newType = new VarType(elementType.type, 1, elementType.value);
} }
NewExprent newExpr = new NewExprent(newType, Collections.<Exprent>emptyList(), null); NewExprent newExpr = new NewExprent(newType, Collections.emptyList(), null);
newExpr.setDirectArrayInit(true); newExpr.setDirectArrayInit(true);
newExpr.setLstArrayElements(elements); newExpr.setLstArrayElements(elements);
return newExpr; return newExpr;

194
src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationTypeAttribute.java
Unescape View File

@ -1,194 +0,0 @@
/*
* Copyright 2000-2014 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.java.decompiler.struct.attr;
import org.jetbrains.java.decompiler.modules.decompiler.exps.AnnotationExprent;
import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
import java.io.DataInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class StructAnnotationTypeAttribute extends StructGeneralAttribute {
private static final int ANNOTATION_TARGET_TYPE_GENERIC_CLASS = 0x00;
private static final int ANNOTATION_TARGET_TYPE_GENERIC_METHOD = 0x01;
private static final int ANNOTATION_TARGET_TYPE_EXTENDS_IMPLEMENTS = 0x10;
private static final int ANNOTATION_TARGET_TYPE_GENERIC_CLASS_BOUND = 0x11;
private static final int ANNOTATION_TARGET_TYPE_GENERIC_METHOD_BOUND = 0x12;
private static final int ANNOTATION_TARGET_TYPE_FIELD = 0x13;
private static final int ANNOTATION_TARGET_TYPE_RETURN = 0x14;
private static final int ANNOTATION_TARGET_TYPE_RECEIVER = 0x15;
private static final int ANNOTATION_TARGET_TYPE_FORMAL = 0x16;
private static final int ANNOTATION_TARGET_TYPE_THROWS = 0x17;
private static final int ANNOTATION_TARGET_TYPE_LOCAL_VARIABLE = 0x40;
private static final int ANNOTATION_TARGET_TYPE_RESOURCE_VARIABLE = 0x41;
private static final int ANNOTATION_TARGET_TYPE_EXCEPTION = 0x42;
private static final int ANNOTATION_TARGET_TYPE_INSTANCEOF = 0x43;
private static final int ANNOTATION_TARGET_TYPE_NEW = 0x44;
private static final int ANNOTATION_TARGET_TYPE_DOUBLE_COLON_NEW = 0x45;
private static final int ANNOTATION_TARGET_TYPE_DOUBLE_COLON_ID = 0x46;
private static final int ANNOTATION_TARGET_TYPE_CAST = 0x47;
private static final int ANNOTATION_TARGET_TYPE_INVOCATION_CONSTRUCTOR = 0x48;
private static final int ANNOTATION_TARGET_TYPE_INVOCATION_METHOD = 0x49;
private static final int ANNOTATION_TARGET_TYPE_GENERIC_DOUBLE_COLON_NEW = 0x4A;
private static final int ANNOTATION_TARGET_TYPE_GENERIC_DOUBLE_COLON_ID = 0x4B;
private static final int ANNOTATION_TARGET_UNION_TYPE_PARAMETER = 1;
private static final int ANNOTATION_TARGET_UNION_SUPERTYPE = 2;
private static final int ANNOTATION_TARGET_UNION_TYPE_PARAMETER_BOUND = 3;
private static final int ANNOTATION_TARGET_UNION_EMPTY = 4;
private static final int ANNOTATION_TARGET_UNION_FORMAL_PARAMETER = 5;
private static final int ANNOTATION_TARGET_UNION_THROWS = 6;
private static final int ANNOTATION_TARGET_UNION_LOCAL_VAR = 7;
private static final int ANNOTATION_TARGET_UNION_CATCH = 8;
private static final int ANNOTATION_TARGET_UNION_OFFSET = 9;
private static final int ANNOTATION_TARGET_UNION_TYPE_ARGUMENT = 10;
@SuppressWarnings("FieldCanBeLocal") private List<AnnotationLocation> locations;
@SuppressWarnings("FieldCanBeLocal") private List<AnnotationExprent> annotations;
@Override
public void initContent(ConstantPool pool) throws IOException {
DataInputStream data = stream();
int len = data.readUnsignedByte();
if (len > 0) {
locations = new ArrayList<AnnotationLocation>(len);
annotations = new ArrayList<AnnotationExprent>(len);
for (int i = 0; i < len; i++) {
locations.add(parseAnnotationLocation(data));
annotations.add(StructAnnotationAttribute.parseAnnotation(data, pool));
}
}
else {
locations = Collections.emptyList();
annotations = Collections.emptyList();
}
}
private static AnnotationLocation parseAnnotationLocation(DataInputStream data) throws IOException {
AnnotationLocation ann_location = new AnnotationLocation();
// target type
ann_location.target_type = data.readUnsignedByte();
// target union
switch (ann_location.target_type) {
case ANNOTATION_TARGET_TYPE_GENERIC_CLASS:
case ANNOTATION_TARGET_TYPE_GENERIC_METHOD:
ann_location.target_union = ANNOTATION_TARGET_UNION_TYPE_PARAMETER;
break;
case ANNOTATION_TARGET_TYPE_EXTENDS_IMPLEMENTS:
ann_location.target_union = ANNOTATION_TARGET_UNION_SUPERTYPE;
break;
case ANNOTATION_TARGET_TYPE_GENERIC_CLASS_BOUND:
case ANNOTATION_TARGET_TYPE_GENERIC_METHOD_BOUND:
ann_location.target_union = ANNOTATION_TARGET_UNION_TYPE_PARAMETER_BOUND;
break;
case ANNOTATION_TARGET_TYPE_FIELD:
case ANNOTATION_TARGET_TYPE_RETURN:
case ANNOTATION_TARGET_TYPE_RECEIVER:
ann_location.target_union = ANNOTATION_TARGET_UNION_EMPTY;
break;
case ANNOTATION_TARGET_TYPE_FORMAL:
ann_location.target_union = ANNOTATION_TARGET_UNION_FORMAL_PARAMETER;
break;
case ANNOTATION_TARGET_TYPE_THROWS:
ann_location.target_union = ANNOTATION_TARGET_UNION_THROWS;
break;
case ANNOTATION_TARGET_TYPE_LOCAL_VARIABLE:
case ANNOTATION_TARGET_TYPE_RESOURCE_VARIABLE:
ann_location.target_union = ANNOTATION_TARGET_UNION_LOCAL_VAR;
break;
case ANNOTATION_TARGET_TYPE_EXCEPTION:
ann_location.target_union = ANNOTATION_TARGET_UNION_CATCH;
break;
case ANNOTATION_TARGET_TYPE_INSTANCEOF:
case ANNOTATION_TARGET_TYPE_NEW:
case ANNOTATION_TARGET_TYPE_DOUBLE_COLON_NEW:
case ANNOTATION_TARGET_TYPE_DOUBLE_COLON_ID:
ann_location.target_union = ANNOTATION_TARGET_UNION_OFFSET;
break;
case ANNOTATION_TARGET_TYPE_CAST:
case ANNOTATION_TARGET_TYPE_INVOCATION_CONSTRUCTOR:
case ANNOTATION_TARGET_TYPE_INVOCATION_METHOD:
case ANNOTATION_TARGET_TYPE_GENERIC_DOUBLE_COLON_NEW:
case ANNOTATION_TARGET_TYPE_GENERIC_DOUBLE_COLON_ID:
ann_location.target_union = ANNOTATION_TARGET_UNION_TYPE_ARGUMENT;
break;
default:
throw new RuntimeException("Unknown target type in a type annotation!");
}
// target union data
switch (ann_location.target_union) {
case ANNOTATION_TARGET_UNION_TYPE_PARAMETER:
case ANNOTATION_TARGET_UNION_FORMAL_PARAMETER:
ann_location.data = new int[]{data.readUnsignedByte()};
break;
case ANNOTATION_TARGET_UNION_SUPERTYPE:
case ANNOTATION_TARGET_UNION_THROWS:
case ANNOTATION_TARGET_UNION_CATCH:
case ANNOTATION_TARGET_UNION_OFFSET:
ann_location.data = new int[]{data.readUnsignedShort()};
break;
case ANNOTATION_TARGET_UNION_TYPE_PARAMETER_BOUND:
ann_location.data = new int[]{data.readUnsignedByte(), data.readUnsignedByte()};
break;
case ANNOTATION_TARGET_UNION_EMPTY:
break;
case ANNOTATION_TARGET_UNION_LOCAL_VAR:
int table_length = data.readUnsignedShort();
ann_location.data = new int[table_length * 3 + 1];
ann_location.data[0] = table_length;
for (int i = 0; i < table_length; ++i) {
ann_location.data[3 * i + 1] = data.readUnsignedShort();
ann_location.data[3 * i + 2] = data.readUnsignedShort();
ann_location.data[3 * i + 3] = data.readUnsignedShort();
}
break;
case ANNOTATION_TARGET_UNION_TYPE_ARGUMENT:
ann_location.data = new int[]{data.readUnsignedShort(), data.readUnsignedByte()};
}
// target path
int path_length = data.readUnsignedByte();
ann_location.target_path_kind = new int[path_length];
ann_location.target_argument_index = new int[path_length];
for (int i = 0; i < path_length; ++i) {
ann_location.target_path_kind[i] = data.readUnsignedByte();
ann_location.target_argument_index[i] = data.readUnsignedByte();
}
return ann_location;
}
private static class AnnotationLocation {
public int target_type;
public int target_union;
public int[] data;
public int[] target_path_kind;
public int[] target_argument_index;
}
}

17
src/org/jetbrains/java/decompiler/struct/attr/StructGeneralAttribute.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2000-2015 JetBrains s.r.o. * Copyright 2000-2016 JetBrains s.r.o.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -28,7 +28,6 @@ import java.io.IOException;
} }
*/ */
public class StructGeneralAttribute { public class StructGeneralAttribute {
public static final String ATTRIBUTE_CODE = "Code"; public static final String ATTRIBUTE_CODE = "Code";
public static final String ATTRIBUTE_INNER_CLASSES = "InnerClasses"; public static final String ATTRIBUTE_INNER_CLASSES = "InnerClasses";
public static final String ATTRIBUTE_SIGNATURE = "Signature"; public static final String ATTRIBUTE_SIGNATURE = "Signature";
@ -73,17 +72,14 @@ public class StructGeneralAttribute {
else if (ATTRIBUTE_ENCLOSING_METHOD.equals(name)) { else if (ATTRIBUTE_ENCLOSING_METHOD.equals(name)) {
attr = new StructEnclosingMethodAttribute(); attr = new StructEnclosingMethodAttribute();
} }
else if (ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS.equals(name) || else if (ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS.equals(name) || ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS.equals(name)) {
ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS.equals(name)) {
attr = new StructAnnotationAttribute(); attr = new StructAnnotationAttribute();
} }
else if (ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS.equals(name) || else if (ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS.equals(name) || ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS.equals(name)) {
ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS.equals(name)) {
attr = new StructAnnotationParameterAttribute(); attr = new StructAnnotationParameterAttribute();
} }
else if (ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(name) || else if (ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(name) || ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(name)) {
ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(name)) { attr = new StructTypeAnnotationAttribute();
attr = new StructAnnotationTypeAttribute();
} }
else if (ATTRIBUTE_LOCAL_VARIABLE_TABLE.equals(name)) { else if (ATTRIBUTE_LOCAL_VARIABLE_TABLE.equals(name)) {
attr = new StructLocalVariableTableAttribute(); attr = new StructLocalVariableTableAttribute();
@ -91,8 +87,7 @@ public class StructGeneralAttribute {
else if (ATTRIBUTE_BOOTSTRAP_METHODS.equals(name)) { else if (ATTRIBUTE_BOOTSTRAP_METHODS.equals(name)) {
attr = new StructBootstrapMethodsAttribute(); attr = new StructBootstrapMethodsAttribute();
} }
else if (ATTRIBUTE_SYNTHETIC.equals(name) || else if (ATTRIBUTE_SYNTHETIC.equals(name) || ATTRIBUTE_DEPRECATED.equals(name)) {
ATTRIBUTE_DEPRECATED.equals(name)) {
attr = new StructGeneralAttribute(); attr = new StructGeneralAttribute();
} }
else if (ATTRIBUTE_LINE_NUMBER_TABLE.equals(name)) { else if (ATTRIBUTE_LINE_NUMBER_TABLE.equals(name)) {

107
src/org/jetbrains/java/decompiler/struct/attr/StructTypeAnnotationAttribute.java
Unescape View File

@ -0,0 +1,107 @@
/*
* Copyright 2000-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.java.decompiler.struct.attr;
import org.jetbrains.java.decompiler.modules.decompiler.exps.AnnotationExprent;
import org.jetbrains.java.decompiler.modules.decompiler.exps.TypeAnnotation;
import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
import java.io.DataInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class StructTypeAnnotationAttribute extends StructGeneralAttribute {
private List<TypeAnnotation> annotations = Collections.emptyList();
@Override
public void initContent(ConstantPool pool) throws IOException {
DataInputStream data = stream();
int len = data.readUnsignedShort();
if (len > 0) {
annotations = new ArrayList<>(len);
for (int i = 0; i < len; i++) {
annotations.add(parse(data, pool));
}
}
else {
annotations = Collections.emptyList();
}
}
private static TypeAnnotation parse(DataInputStream data, ConstantPool pool) throws IOException {
int targetType = data.readUnsignedByte();
int target = targetType << 24;
switch (targetType) {
case TypeAnnotation.CLASS_TYPE_PARAMETER:
case TypeAnnotation.METHOD_TYPE_PARAMETER:
case TypeAnnotation.METHOD_PARAMETER:
target |= data.readUnsignedByte();
break;
case TypeAnnotation.SUPER_TYPE_REFERENCE:
case TypeAnnotation.CLASS_TYPE_PARAMETER_BOUND:
case TypeAnnotation.METHOD_TYPE_PARAMETER_BOUND:
case TypeAnnotation.THROWS_REFERENCE:
case TypeAnnotation.CATCH_CLAUSE:
case TypeAnnotation.EXPR_INSTANCEOF:
case TypeAnnotation.EXPR_NEW:
case TypeAnnotation.EXPR_CONSTRUCTOR_REF:
case TypeAnnotation.EXPR_METHOD_REF:
target |= data.readUnsignedShort();
break;
case TypeAnnotation.TYPE_ARG_CAST:
case TypeAnnotation.TYPE_ARG_CONSTRUCTOR_CALL:
case TypeAnnotation.TYPE_ARG_METHOD_CALL:
case TypeAnnotation.TYPE_ARG_CONSTRUCTOR_REF:
case TypeAnnotation.TYPE_ARG_METHOD_REF:
data.skipBytes(3);
break;
case TypeAnnotation.LOCAL_VARIABLE:
case TypeAnnotation.RESOURCE_VARIABLE:
data.skipBytes(data.readUnsignedShort() * 6);
break;
case TypeAnnotation.FIELD:
case TypeAnnotation.METHOD_RETURN_TYPE:
case TypeAnnotation.METHOD_RECEIVER:
break;
default:
throw new RuntimeException("unknown target type: " + targetType);
}
int pathLength = data.readUnsignedByte();
byte[] path = null;
if (pathLength > 0) {
path = new byte[2 * pathLength];
data.readFully(path);
}
AnnotationExprent annotation = StructAnnotationAttribute.parseAnnotation(data, pool);
return new TypeAnnotation(target, path, annotation);
}
public List<TypeAnnotation> getAnnotations() {
return annotations;
}
}

1
test/org/jetbrains/java/decompiler/SingleClassesTest.java
Unescape View File

@ -84,6 +84,7 @@ public class SingleClassesTest {
@Test public void testMethodReferenceLetterClass() { doTest("pkg/TestMethodReferenceLetterClass"); } @Test public void testMethodReferenceLetterClass() { doTest("pkg/TestMethodReferenceLetterClass"); }
@Test public void testMemberAnnotations() { doTest("pkg/TestMemberAnnotations"); } @Test public void testMemberAnnotations() { doTest("pkg/TestMemberAnnotations"); }
@Test public void testMoreAnnotations() { doTest("pkg/MoreAnnotations"); } @Test public void testMoreAnnotations() { doTest("pkg/MoreAnnotations"); }
@Test public void testTypeAnnotations() { doTest("pkg/TypeAnnotations"); }
@Test public void testStaticNameClash() { doTest("pkg/TestStaticNameClash"); } @Test public void testStaticNameClash() { doTest("pkg/TestStaticNameClash"); }
@Test public void testExtendingSubclass() { doTest("pkg/TestExtendingSubclass"); } @Test public void testExtendingSubclass() { doTest("pkg/TestExtendingSubclass"); }
@Test public void testSyntheticAccess() { doTest("pkg/TestSyntheticAccess"); } @Test public void testSyntheticAccess() { doTest("pkg/TestSyntheticAccess"); }

BIN
testData/classes/pkg/TypeAnnotations$MixA.class
View File

Binary file not shown.

BIN
testData/classes/pkg/TypeAnnotations$TA.class
View File

Binary file not shown.

BIN
testData/classes/pkg/TypeAnnotations.class
View File

Binary file not shown.

44
testData/results/TypeAnnotations.dec
Unescape View File

@ -0,0 +1,44 @@
package pkg;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
class TypeAnnotations {
@TypeAnnotations.TA("field type")
private String f1;
@TypeAnnotations.MixA("field and type")
private String f2;
@TypeAnnotations.TA("return type")
int m1() {
return 42;// 18
}
void m2(@TypeAnnotations.TA("parameter") int var1) {
}// 21
@Target({ElementType.FIELD, ElementType.TYPE_USE})
@interface MixA {
String value();
}
@Target({ElementType.TYPE_USE})
@interface TA {
String value();
}
}
class 'pkg/TypeAnnotations' {
method 'm1 ()I' {
0 13
2 13
}
method 'm2 (I)V' {
0 17
}
}
Lines mapping:
18 <-> 14
21 <-> 18

22
testData/src/pkg/TypeAnnotations.java
Unescape View File

@ -0,0 +1,22 @@
package pkg;
import java.lang.annotation.*;
import java.util.*;
class TypeAnnotations {
@Target(ElementType.TYPE_USE)
@interface TA { String value(); }
@Target({ElementType.FIELD, ElementType.TYPE_USE})
@interface MixA { String value(); }
private @TA("field type") String f1;
private @MixA("field and type") String f2;
@TA("return type") int m1() {
return 42;
}
void m2(@TA("parameter") int i) { }
}
Write Preview
Loading…
Cancel
Save