ra/fernflower
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki 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.
This commit is contained in:
Roman Shevchenko
2016-04-21 21:22:36 +02:00
parent a8403429ef
commit 52b31bf325
13 changed files with 316 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
src/org/jetbrains/java/decompiler/main/ClassWriter.java
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();
}
}
} }
} }
} }

19
src/org/jetbrains/java/decompiler/modules/decompiler/exps/AnnotationExprent.java
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 Normal file
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
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
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
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 Normal file
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
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 Normal file
View File

Binary file not shown.

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

Binary file not shown.

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

Binary file not shown.

44
testData/results/TypeAnnotations.dec Normal file
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 Normal file
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) { }
}