/** * @return a ClassDescriptor for the method's class */ @Override public ClassDescriptor getClassDescriptor() { return DescriptorFactory.createClassDescriptor(slashedClassName); }
public ClassDescriptor getClassDescriptor() { return DescriptorFactory.createClassDescriptorFromDottedClassName(className); }
@Override protected DescriptorFactory initialValue() { return new DescriptorFactory(); } };
public static ClassDescriptor createClassOrObjectDescriptorFromSignature(String signature) { if (signature.charAt(0) == '[') { return createClassDescriptor("java/lang/Object"); } return createClassDescriptorFromSignature(signature); }
public void canonicalizeAll() { DescriptorFactory descriptorFactory = DescriptorFactory.instance(); for (XMethod m : methods.values()) { if (m instanceof MethodDescriptor) { descriptorFactory.canonicalize((MethodDescriptor) m); } } for (XField f : fields.values()) { if (f instanceof FieldDescriptor) { descriptorFactory.canonicalize((FieldDescriptor) f); } } }
/** * Create a class descriptor from a resource name. * * @param resourceName * the resource name * @return the class descriptor */ public static ClassDescriptor createClassDescriptorFromResourceName(String resourceName) { if (!isClassResource(resourceName)) { throw new IllegalArgumentException("Resource " + resourceName + " is not a class"); } return createClassDescriptor(resourceName.substring(0, resourceName.length() - 6)); }
public static boolean instanceOf(JavaClass subtype, @DottedClassName String dottedSupertype) { if (subtype.getClassName().equals(dottedSupertype) || subtype.getSuperclassName().equals(dottedSupertype)) { return true; } if ("java.lang.Object".equals(subtype.getSuperclassName()) && subtype.getInterfaceIndices().length == 0) { return false; } Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2(); ClassDescriptor subDescriptor = DescriptorFactory.createClassDescriptor(subtype); ClassDescriptor superDescriptor = DescriptorFactory.createClassDescriptorFromDottedClassName(dottedSupertype); try { return subtypes2.isSubtype(subDescriptor, superDescriptor); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); return false; } }
/** * Constructor. * * @param annotationClass * JVM signature of the annotation class */ public AnnotationValue(String annotationClass) { this.annotationClass = DescriptorFactory.createClassDescriptorFromSignature(annotationClass); }
/** * Create a class descriptor from a resource name. * * @param resourceName * the resource name * @return the class descriptor * @deprecated Use * {@link DescriptorFactory#createClassDescriptorFromResourceName(String)} * instead */ @Deprecated public static ClassDescriptor fromResourceName(String resourceName) { return DescriptorFactory.createClassDescriptorFromResourceName(resourceName); }
/** * Create a class descriptor from a field signature * * @deprecated Use * {@link DescriptorFactory#createClassDescriptorFromFieldSignature(String)} * instead * */ @Deprecated public static @CheckForNull ClassDescriptor fromFieldSignature(String signature) { return DescriptorFactory.createClassDescriptorFromFieldSignature(signature); }
continue; ClassDescriptor operandClass = DescriptorFactory.getClassDescriptor(operand); if (!isGenericCollection(operandClass)) { continue; .createClassOrObjectDescriptorFromSignature(expectedType.getSignature()); ClassDescriptor actualClassDescriptor = DescriptorFactory.createClassOrObjectDescriptorFromSignature(equalsType .getSignature()); ClassSummary classSummary = AnalysisContext.currentAnalysisContext().getClassSummary();
/** * Protected to allow Eclipse plugin remember some cache data for later reuse */ protected void clearCaches() { DescriptorFactory.clearInstance(); ObjectTypeFactory.clearInstance(); TypeQualifierApplications.clearInstance(); TypeQualifierAnnotation.clearInstance(); TypeQualifierValue.clearInstance(); // Make sure the codebases on the classpath are closed AnalysisContext.removeCurrentAnalysisContext(); Global.removeAnalysisCacheForCurrentThread(); IO.close(classPath); }
@Override public void sawOpcode(int seen) { if (seen == Const.INVOKEVIRTUAL) { if ("equals".equals(getNameConstantOperand()) && "(Ljava/lang/Object;)Z".equals(getSigConstantOperand())) { OpcodeStack.Item item = stack.getStackItem(1); ClassDescriptor c = DescriptorFactory.createClassDescriptorFromSignature(item.getSignature()); check(c); } else if ("java/lang/Class".equals(getClassConstantOperand()) && ("isInstance".equals(getNameConstantOperand()) || "cast".equals(getNameConstantOperand()))) { OpcodeStack.Item item = stack.getStackItem(1); if ("Ljava/lang/Class;".equals(item.getSignature())) { Object value = item.getConstant(); if (value instanceof String) { ClassDescriptor c = DescriptorFactory.createClassDescriptor((String) value); check(c); } } } } else if (seen == Const.INSTANCEOF || seen == Const.CHECKCAST) { check(getClassDescriptorOperand()); } }
public EnumValue(String desc, String value) { this.desc = DescriptorFactory.createClassDescriptorFromSignature(desc); this.value = value; }
public static XMethod createXMethod(MethodDescriptor desc) { XFactory xFactory = AnalysisContext.currentXFactory(); XMethod m = xFactory.methods.get(desc); if (m != null) { return m; } m = xFactory.resolveXMethod(desc); if (m instanceof MethodDescriptor) { xFactory.methods.put((MethodDescriptor) m, m); DescriptorFactory.instance().canonicalize((MethodDescriptor) m); } else { xFactory.methods.put(desc, m); } return m; }
@Override public ClassDescriptor getClassDescriptor() { return DescriptorFactory.createClassDescriptorFromResourceName(getResourceName()); }
return; ClassDescriptor classOfField = DescriptorFactory.createClassDescriptorFromFieldSignature(aField.getSignature()); String tBugType = null; int priority = aField.isPublic() && aField.isFinal() && aField.getName().equals(aField.getName().toUpperCase())
continue; ClassDescriptor operandClass = DescriptorFactory.getClassDescriptor(operand); if (!isGenericCollection(operandClass)) { continue; .createClassOrObjectDescriptorFromSignature(expectedType.getSignature()); ClassDescriptor actualClassDescriptor = DescriptorFactory.createClassOrObjectDescriptorFromSignature(equalsType .getSignature()); ClassSummary classSummary = AnalysisContext.currentAnalysisContext().getClassSummary();
/** * Protected to allow Eclipse plugin remember some cache data for later reuse */ protected void clearCaches() { DescriptorFactory.clearInstance(); ObjectTypeFactory.clearInstance(); TypeQualifierApplications.clearInstance(); TypeQualifierAnnotation.clearInstance(); TypeQualifierValue.clearInstance(); // Make sure the codebases on the classpath are closed AnalysisContext.removeCurrentAnalysisContext(); Global.removeAnalysisCacheForCurrentThread(); if (classPath != null) { classPath.close(); } }
public static ClassDescriptor[] createClassDescriptor(String[] classNames) { if (classNames.length == 0) { return ClassDescriptor.EMPTY_ARRAY; } ClassDescriptor[] result = new ClassDescriptor[classNames.length]; for (int i = 0; i < classNames.length; i++) { result[i] = createClassDescriptor(classNames[i]); } return result; }