/** * Returns the Java type name type corresponding to the given type * descriptor. * * @param desc * The type descriptor. * @return The type name. */ public static String getType(String desc) { return getType(Type.getType(desc)); }
@Override public void visitLdcInsn(final Object cst) { if (cst instanceof Type) { visitorHelper.resolveType(SignatureHelper.getType((Type) cst), containingType); } }
/** * Returns the Java type name corresponding to the given internal name. * * @param desc * The internal name. * @return The type name. */ public static String getObjectType(String desc) { return getType(Type.getObjectType(desc)); }
@Override public void visitMultiANewArrayInsn(final String desc, final int dims) { visitorHelper.resolveType(SignatureHelper.getType(desc), containingType); }
@Override public AnnotationVisitor visitAnnotation(String arg0, boolean arg1) { AnnotationValueDescriptor annotationDescriptor = visitorHelper.addAnnotation(containingType, fieldDescriptor, SignatureHelper.getType(arg0)); return new AnnotationVisitor(containingType, annotationDescriptor, visitorHelper); } }
@Override public AnnotationVisitor visitAnnotation(final String desc, final boolean visible) { AnnotationValueDescriptor annotationDescriptor = visitorHelper.addAnnotation(containingType, methodDescriptor, SignatureHelper.getType(desc)); return new AnnotationVisitor(containingType, annotationDescriptor, visitorHelper); }
/** * Return the type name of the given ASM type. * * @param t * The ASM type. * @return The type name. */ public static String getType(final Type t) { switch (t.getSort()) { case Type.ARRAY: return getType(t.getElementType()); default: return t.getClassName(); } }
@Override public org.objectweb.asm.AnnotationVisitor visitParameterAnnotation(final int parameter, final String desc, final boolean visible) { String annotationType = SignatureHelper.getType(desc); if (JAVA_LANG_SYNTHETIC.equals(annotationType)) { // Ignore synthetic parameters add the start of the signature, i.e. // determine the number of synthetic parameters syntheticParameters = Math.max(syntheticParameters, parameter + 1); return null; } ParameterDescriptor parameterDescriptor = visitorHelper.getParameterDescriptor(methodDescriptor, parameter - syntheticParameters); if (parameterDescriptor == null) { LOGGER.warn("Cannot find parameter with index " + (parameter - syntheticParameters) + " in method signature " + containingType.getTypeDescriptor().getFullQualifiedName() + "#" + methodDescriptor.getSignature()); return null; } AnnotationValueDescriptor annotationDescriptor = visitorHelper.addAnnotation(containingType, parameterDescriptor, SignatureHelper.getType(desc)); return new AnnotationVisitor(containingType, annotationDescriptor, visitorHelper); }
@Override public AnnotationVisitor visitAnnotation(final String desc, final boolean visible) { AnnotationValueDescriptor annotationDescriptor = visitorHelper.addAnnotation(cachedType, cachedType.getTypeDescriptor(), SignatureHelper.getType(desc)); return new AnnotationVisitor(cachedType, annotationDescriptor, visitorHelper); }
@Override public AnnotationVisitor visitAnnotation(final String name, final String desc) { AnnotationValueDescriptor valueDescriptor = createValue(AnnotationValueDescriptor.class, name); valueDescriptor.setType(visitorHelper.resolveType(SignatureHelper.getType(desc), containingType).getTypeDescriptor()); addValue(name, valueDescriptor); return new AnnotationVisitor(containingType, valueDescriptor, visitorHelper); }
@Override public void visitEnum(final String name, final String desc, final String value) { EnumValueDescriptor valueDescriptor = createValue(EnumValueDescriptor.class, name); TypeCache.CachedType cachedTypeDescriptor = visitorHelper.resolveType(SignatureHelper.getType(desc), containingType); FieldDescriptor fieldDescriptor = visitorHelper.getFieldDescriptor(cachedTypeDescriptor, SignatureHelper.getFieldSignature(value, desc)); valueDescriptor.setType(visitorHelper.resolveType(Enum.class.getName(), containingType).getTypeDescriptor()); valueDescriptor.setValue(fieldDescriptor); addValue(name, valueDescriptor); }
@Override public void visit(final String name, final Object value) { if (value instanceof Type) { String type = SignatureHelper.getType((Type) value); ClassValueDescriptor valueDescriptor = createValue(ClassValueDescriptor.class, name); valueDescriptor.setValue(visitorHelper.resolveType(type, containingType).getTypeDescriptor()); addValue(name, valueDescriptor); } else { PrimitiveValueDescriptor valueDescriptor = createValue(PrimitiveValueDescriptor.class, name); TypeDescriptor typeDescriptor = visitorHelper.resolveType(value.getClass().getName(), containingType).getTypeDescriptor(); valueDescriptor.setType(typeDescriptor); valueDescriptor.setValue(value); addValue(name, valueDescriptor); } }
@Override public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, final int index) { if (visitorHelper.getClassModelConfiguration().isMethodDeclaresVariable() && !THIS.equals(name)) { final VariableDescriptor variableDescriptor = visitorHelper.getVariableDescriptor(name, SignatureHelper.getFieldSignature(name, desc)); if (signature == null) { TypeDescriptor type = visitorHelper.resolveType(SignatureHelper.getType((desc)), containingType).getTypeDescriptor(); variableDescriptor.setType(type); } else { new SignatureReader(signature).accept(new AbstractTypeSignatureVisitor(containingType, visitorHelper) { @Override public SignatureVisitor visitArrayType() { return dependentTypeSignatureVisitor; } @Override public SignatureVisitor visitTypeArgument(char wildcard) { return dependentTypeSignatureVisitor; } @Override public void visitEnd(TypeDescriptor resolvedTypeDescriptor) { variableDescriptor.setType(resolvedTypeDescriptor); } }); } methodDescriptor.getVariables().add(variableDescriptor); } }
@Override public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) { MethodDescriptor methodDescriptor = visitorHelper.getMethodDescriptor(cachedType, SignatureHelper.getMethodSignature(name, desc)); methodDescriptor.setName(name); setModifiers(access, methodDescriptor); if (hasFlag(access, Opcodes.ACC_ABSTRACT)) { methodDescriptor.setAbstract(Boolean.TRUE); } if (hasFlag(access, Opcodes.ACC_NATIVE)) { methodDescriptor.setNative(Boolean.TRUE); } if (signature == null) { String returnType = SignatureHelper.getType(org.objectweb.asm.Type.getReturnType(desc)); methodDescriptor.setReturns(visitorHelper.resolveType(returnType, cachedType).getTypeDescriptor()); org.objectweb.asm.Type[] types = org.objectweb.asm.Type.getArgumentTypes(desc); for (int i = 0; i < types.length; i++) { String parameterType = SignatureHelper.getType(types[i]); TypeDescriptor typeDescriptor = visitorHelper.resolveType(parameterType, cachedType).getTypeDescriptor(); ParameterDescriptor parameterDescriptor = visitorHelper.addParameterDescriptor(methodDescriptor, i); parameterDescriptor.setType(typeDescriptor); } } else { new SignatureReader(signature).accept(new MethodSignatureVisitor(cachedType, methodDescriptor, visitorHelper, dependentTypeSignatureVisitor)); } for (int i = 0; exceptions != null && i < exceptions.length; i++) { TypeDescriptor exceptionType = visitorHelper.resolveType(SignatureHelper.getObjectType(exceptions[i]), cachedType).getTypeDescriptor(); methodDescriptor.getDeclaredThrowables().add(exceptionType); } return new MethodVisitor(cachedType, methodDescriptor, visitorHelper, dependentTypeSignatureVisitor); }
setModifiers(access, fieldDescriptor); if (signature == null) { TypeDescriptor type = visitorHelper.resolveType(SignatureHelper.getType((desc)), cachedType).getTypeDescriptor(); fieldDescriptor.setType(type); } else { visitorHelper.resolveType(SignatureHelper.getType((org.objectweb.asm.Type) value), cachedType);