if (mtClass.isClass() ? cls.instanceOf(mtClass) : cls.implementationOf(mtClass)) { mtClassName = mtClass.getClassName(); super.visitClassContext(classContext);
String clsName = getDottedClassConstantOperand(); JavaClass cls = Repository.lookupClass(clsName); if (cls.implementationOf(collectionClass)) { bugAccumulator.accumulateBug( new BugInstance(this, "ITA_INEFFICIENT_TO_ARRAY", LOW_PRIORITY).addClassAndMethod(this), this);
/** * @return true, if clazz is an implementation of interface inter * @throws ClassNotFoundException if any superclasses or superinterfaces * of clazz can't be found */ public static boolean implementationOf( final JavaClass clazz, final JavaClass inter ) throws ClassNotFoundException { return clazz.implementationOf(inter); }
/** * @return true, if clazz is an implementation of interface inter */ public static boolean implementationOf(JavaClass clazz, JavaClass inter) { return clazz.implementationOf(inter); }
/** * determines if the current class name is derived from List, Set or Map * * @param clsName * the class to determine it's parentage * @return if the class is a List, Set or Map * * @throws ClassNotFoundException * if the cls parameter can't be found */ public static boolean isListSetMap(String clsName) throws ClassNotFoundException { JavaClass cls = Repository.lookupClass(clsName); return (cls.implementationOf(LIST_CLASS) || cls.implementationOf(SET_CLASS) || cls.implementationOf(MAP_CLASS)); }
/** * determines if the current class name is derived from List, Set or Map * * @param clsName * the class to determine it's parentage * @return if the class is a List, Set or Map * * @throws ClassNotFoundException * if the cls parameter can't be found */ public static boolean isListSetMap(String clsName) throws ClassNotFoundException { JavaClass cls = Repository.lookupClass(clsName); return (cls.implementationOf(LIST_CLASS) || cls.implementationOf(SET_CLASS) || cls.implementationOf(MAP_CLASS)); }
private void removeInheritedInterfaces(Map<JavaClass, List<MethodInfo>> definers) throws ClassNotFoundException { List<JavaClass> infs = new ArrayList<>(definers.keySet()); for (int i = 0; i < (infs.size() - 1); i++) { for (int j = i + 1; j < infs.size(); j++) { JavaClass inf1 = infs.get(i); JavaClass inf2 = infs.get(j); if (inf1.implementationOf(inf2)) { infs.remove(i); definers.remove(inf1); i--; j = infs.size(); } else if (inf2.implementationOf(inf1)) { infs.remove(j); definers.remove(inf2); j--; } else { return; } } } }
private void removeInheritedInterfaces(Map<JavaClass, List<MethodInfo>> definers) throws ClassNotFoundException { List<JavaClass> infs = new ArrayList<>(definers.keySet()); for (int i = 0; i < (infs.size() - 1); i++) { for (int j = i + 1; j < infs.size(); j++) { JavaClass inf1 = infs.get(i); JavaClass inf2 = infs.get(j); if (inf1.implementationOf(inf2)) { infs.remove(i); definers.remove(inf1); i--; j = infs.size(); } else if (inf2.implementationOf(inf1)) { infs.remove(j); definers.remove(inf2); j--; } else { return; } } } }
/** * returns whether the class implements the interface * * @param cls * the class * @param inf * the interface to check * @return if the class implements the interface */ private boolean isImplementationOf(JavaClass cls, JavaClass inf) { try { if (cls == null) { return false; } if (cls.implementationOf(inf)) { return true; } } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); } return false; }
/** Equivalent to runtime "instanceof" operator. * * @return true if this JavaClass is derived from teh super class */ public final boolean instanceOf(JavaClass super_class) { if(this.equals(super_class)) return true; JavaClass[] super_classes = getSuperClasses(); for(int i=0; i < super_classes.length; i++) { if(super_classes[i].equals(super_class)) { return true; } } if(super_class.isInterface()) { return implementationOf(super_class); } return false; }
/** * returns whether the class name is derived from java.util.Collection * * @param className * the class to check * @return whether the class is a collection */ private boolean isCollection(@SlashedClassName String className) { try { JavaClass cls = Repository.lookupClass(className); return cls.implementationOf(collectionClass) && !exceptionClasses.contains(cls); } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); return false; } }
/** * returns whether the class name is derived from java.util.Collection * * @param className * the class to check * @return whether the class is a collection */ private boolean isCollection(@SlashedClassName String className) { try { JavaClass cls = Repository.lookupClass(className); return cls.implementationOf(collectionClass) && !exceptionClasses.contains(cls); } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); return false; } }
private boolean isMap(Field obj) { try { String sig = obj.getSignature(); if (!sig.startsWith(Values.SIG_QUALIFIED_CLASS_PREFIX)) { return false; } sig = SignatureUtils.trimSignature(sig); JavaClass fieldClass = Repository.lookupClass(sig); return fieldClass.implementationOf(mapInterface) && !fieldClass.instanceOf(propertiesClass); } catch (ClassNotFoundException e) { return false; } }
private boolean isMap(Field obj) { try { String sig = obj.getSignature(); if (!sig.startsWith(Values.SIG_QUALIFIED_CLASS_PREFIX)) { return false; } sig = SignatureUtils.trimSignature(sig); JavaClass fieldClass = Repository.lookupClass(sig); return fieldClass.implementationOf(mapInterface) && !fieldClass.instanceOf(propertiesClass); } catch (ClassNotFoundException e) { return false; } }
/** * overrides the method to check for Serializable */ @Override public void visitClassContext(ClassContext classContext) { try { JavaClass cls = classContext.getJavaClass(); if ((serializableClass != null) && cls.implementationOf(serializableClass)) { super.visitClassContext(classContext); } } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); } }
/** * overrides the method to check for Serializable */ @Override public void visitClassContext(ClassContext classContext) { try { JavaClass cls = classContext.getJavaClass(); if ((serializableClass != null) && cls.implementationOf(serializableClass)) { super.visitClassContext(classContext); } } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); } }
/** * implements the visitor to create and clear the const0loop set * * @param classContext * the context object of the currently parsed class */ @Override public void visitClassContext(ClassContext classContext) { try { if ((invocationHandlerClass != null) && classContext.getJavaClass().implementationOf(invocationHandlerClass)) { return; } iConst0Looped = new BitSet(); stack = new OpcodeStack(); super.visitClassContext(classContext); } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); } finally { iConst0Looped = null; stack = null; } }
private void sawOpcodeAfterLoad(int seen, int pc) throws ClassNotFoundException { if (((seen == INVOKEVIRTUAL) || (seen == INVOKEINTERFACE)) && "close".equals(getNameConstantOperand()) && SignatureBuilder.SIG_VOID_TO_VOID.equals(getSigConstantOperand()) && Repository.lookupClass(getClassConstantOperand()).implementationOf(autoCloseableClass)) { TryBlock tb = findEnclosingFinally(pc); if ((tb != null) && (stack.getStackDepth() > 0)) { OpcodeStack.Item itm = stack.getStackItem(0); int closeableReg = itm.getRegisterNumber(); if (closeableReg >= 0) { Integer storePC = regStoredPCs.get(Integer.valueOf(closeableReg)); if ((storePC != null) && (storePC.intValue() <= tb.getStartPC())) { bugPC = pc; closePC = tb.getHandlerEndPC(); } } } } state = State.SEEN_NOTHING; lastNullCheckedReg = -1; }
private void sawOpcodeAfterLoad(int seen, int pc) throws ClassNotFoundException { if (((seen == Const.INVOKEVIRTUAL) || (seen == Const.INVOKEINTERFACE)) && "close".equals(getNameConstantOperand()) && SignatureBuilder.SIG_VOID_TO_VOID.equals(getSigConstantOperand()) && Repository.lookupClass(getClassConstantOperand()).implementationOf(autoCloseableClass)) { TryBlock tb = findEnclosingFinally(pc); if ((tb != null) && (stack.getStackDepth() > 0)) { OpcodeStack.Item itm = stack.getStackItem(0); int closeableReg = itm.getRegisterNumber(); if (closeableReg >= 0) { Integer storePC = regStoredPCs.get(Integer.valueOf(closeableReg)); if ((storePC != null) && (storePC.intValue() <= tb.getStartPC())) { bugPC = pc; closePC = tb.getHandlerEndPC(); } } } } state = State.SEEN_NOTHING; lastNullCheckedReg = -1; }
/** Equivalent to runtime "instanceof" operator. * * @return true if this JavaClass is derived from the super class * @throws ClassNotFoundException if superclasses or superinterfaces * of this object can't be found */ public final boolean instanceOf( final JavaClass super_class ) throws ClassNotFoundException { if (this.equals(super_class)) { return true; } final JavaClass[] super_classes = getSuperClasses(); for (final JavaClass super_classe : super_classes) { if (super_classe.equals(super_class)) { return true; } } if (super_class.isInterface()) { return implementationOf(super_class); } return false; }