public boolean isCalled(XMethod m) { if (Const.STATIC_INITIALIZER_NAME.equals(m.getName())) { return true; } return calledMethods.contains(m); }
public static boolean assertsFirstParameterIsNonnull(XMethod m) { return ("checkNonNull".equalsIgnoreCase(m.getName()) || "checkNotNull".equalsIgnoreCase(m.getName()) // JDK 7 java.util.Objects.requireNonNull(Object) || "requireNonNull".equals(m.getName()) // org.eclipse.core.runtime.Assert(Object) || "isNotNull".equalsIgnoreCase(m.getName()) || "assertNotNull".equalsIgnoreCase(m.getName())) && m.getSignature().startsWith("(Ljava/lang/Object;"); }
private static boolean newlyConstructedObject(OpcodeStack.Item item) { XMethod method = item.getReturnValueOf(); if (method == null) { return false; } return Const.CONSTRUCTOR_NAME.equals(method.getName()); }
public boolean isServletWriter() { if (getSpecialKind() == Item.SERVLET_OUTPUT) { return true; } if ("Ljavax/servlet/ServletOutputStream;".equals(getSignature())) { return true; } XMethod writingToSource = getReturnValueOf(); return writingToSource != null && "javax.servlet.http.HttpServletResponse".equals(writingToSource.getClassName()) && ("getWriter".equals(writingToSource.getName()) || "getOutputStream".equals(writingToSource.getName())); }
private int taintPriority(OpcodeStack.Item writing) { if (writing == null) { return Priorities.NORMAL_PRIORITY; } XMethod method = writing.getReturnValueOf(); if (method != null && "getParameter".equals(method.getName()) && "javax.servlet.http.HttpServletRequest".equals(method.getClassName())) { return Priorities.HIGH_PRIORITY; } return Priorities.NORMAL_PRIORITY; }
public Set<ProgramPoint> getCalledFromSuperConstructor(ClassDescriptor superClass, XMethod calledFromConstructor) { if (!callsOverriddenMethodsFromConstructor.contains(superClass)) { return Collections.emptySet(); } for (Map.Entry<XMethod, Set<ProgramPoint>> e : selfMethodsCalledFromConstructor.entrySet()) { XMethod m = e.getKey(); if (m.getName().equals(calledFromConstructor.getName()) && m.getClassDescriptor().equals(calledFromConstructor.getClassDescriptor())) { String sig1 = m.getSignature(); String sig2 = calledFromConstructor.getSignature(); sig1 = sig1.substring(0, sig1.indexOf(')')); sig2 = sig2.substring(0, sig2.indexOf(')')); if (sig1.equals(sig2)) { return e.getValue(); } } } return Collections.emptySet(); }
public static boolean confusingMethodNamesWrongCapitalization(XMethod m1, XMethod m2) { if (m1.isStatic() != m2.isStatic()) { return false; } if (m1.getClassName().equals(m2.getClassName())) { return false; } if (m1.getName().equals(m2.getName())) { return false; } if (m1.getName().equalsIgnoreCase(m2.getName()) && removePackageNamesFromSignature(m1.getSignature()).equals(removePackageNamesFromSignature(m2.getSignature()))) { return true; } return false; }
private static String getDetailedSignature(XMethod m2) { return m2.getName() + m2.getSignature() + m2.isStatic(); }
/** * Set method hash for given method. * * @param method * the method * @param methodHash * the method hash */ public void setMethodHash(XMethod method, byte[] methodHash) { methodHashMap.put(method, new MethodHash(method.getName(), method.getSignature(), method.isStatic(), methodHash)); }
public static boolean likelyTestCase(XMethod m) { if (m.getAnnotation(JUNIT4TEST) != null) { return true; } ClassDescriptor c = m.getClassDescriptor(); if (m.getName().startsWith("test") || m.getName().startsWith("assert")) { Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2(); try { if (subtypes2.isSubtype(c, JUNIT3TESTCASE)) { return true; } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } } return false; }
public static Set<XMethod> resolveVirtualMethodCallTargets(XMethod target, boolean receiverTypeIsExact, boolean invokeSpecial) throws ClassNotFoundException { return resolveVirtualMethodCallTargets(target.getClassDescriptor(), target.getName(), target.getSignature(), receiverTypeIsExact, invokeSpecial); }
private @CheckForNull XMethod getConstructorThatCallsSuperConstructor(XMethod superConstructor) { FieldSummary fieldSummary = AnalysisContext.currentAnalysisContext().getFieldSummary(); XMethod lookfor = "()V".equals(superConstructor.getSignature()) ? null : superConstructor; for (XMethod m : getXClass().getXMethods()) { if (Const.CONSTRUCTOR_NAME.equals(m.getName())) { if (fieldSummary.getSuperCall(m) == lookfor) { return m; } } } return null; }
/** * Convenience method for generating a method signature in human readable * form. * * @param xmethod * an XMethod * @return the formatted version of that signature */ public static String convertMethodSignature(XMethod xmethod) { @DottedClassName String className = xmethod.getClassName(); assert className.indexOf('/') == -1; return convertMethodSignature(className, xmethod.getName(), xmethod.getSignature()); }
public static @CheckForNull XMethod definedIn(JavaClass clazz, XMethod m) { for (Method m2 : clazz.getMethods()) { if (m.getName().equals(m2.getName()) && m.getSignature().equals(m2.getSignature()) && m.isStatic() == m2.isStatic()) { return XFactory.createXMethod(clazz, m2); } } return null; }
private boolean classDefinesMethod(JavaClass c, XMethod m) { for (Method definedMethod : c.getMethods()) { if (definedMethod.getName().equals(m.getName()) && definedMethod.getSignature().equals(m.getSignature()) && definedMethod.isStatic() == m.isStatic()) { return true; } } return false; }
/** * Create a MethodAnnotation from an XMethod. * * @param xmethod * the XMethod * @return the MethodAnnotation */ public static MethodAnnotation fromXMethod(XMethod xmethod) { return fromForeignMethod(xmethod.getClassName(), xmethod.getName(), xmethod.getSignature(), xmethod.isStatic()); }
/** * Constructor. * * @param method * an XMethod specifying a specific method in a specific class * @throws ClassNotFoundException */ public JavaClassAndMethod(XMethod method) throws ClassNotFoundException { this.javaClass = Repository.lookupClass(method.getClassName()); for (Method m : javaClass.getMethods()) { if (m.getName().equals(method.getName()) && m.getSignature().equals(method.getSignature()) && m.isStatic() == method.isStatic()) { this.method = m; return; } } throw new IllegalArgumentException("Can't find " + method); }
@Override public void writeXML(XMLOutput xmlOutput) throws IOException { xmlOutput.startTag(CLASS_HASH_ELEMENT_NAME); xmlOutput.addAttribute("class", className); xmlOutput.addAttribute("value", hashToString(classHash)); xmlOutput.stopTag(false); for (Map.Entry<XMethod, MethodHash> entry : methodHashMap.entrySet()) { xmlOutput.startTag(METHOD_HASH_ELEMENT_NAME); xmlOutput.addAttribute("name", entry.getKey().getName()); xmlOutput.addAttribute("signature", entry.getKey().getSignature()); xmlOutput.addAttribute("isStatic", String.valueOf(entry.getKey().isStatic())); xmlOutput.addAttribute("value", hashToString(entry.getValue().getMethodHash())); xmlOutput.stopTag(true); } xmlOutput.closeTag(CLASS_HASH_ELEMENT_NAME); }
@Override public void sawOpcode(int seen) { if (seen == Const.INVOKESPECIAL) { XMethod m = getXMethodOperand(); if (m == null) { return; } XClass c = getXClass(); int nameDistance = EditDistance.editDistance(m.getName(), getMethodName()); if (nameDistance < 4 && c.findMatchingMethod(m.getMethodDescriptor()) == null && !m.isFinal()) { potentialSuperCall = m; } } }
/** * Create a SourceLineAnnotation covering an entire method. * * @param javaClass * JavaClass containing the method * @param xmethod * the method * @return a SourceLineAnnotation for the entire method */ public static SourceLineAnnotation forEntireMethod(JavaClass javaClass, XMethod xmethod) { JavaClassAndMethod m = Hierarchy.findMethod(javaClass, xmethod.getName(), xmethod.getSignature()); if (m == null) { return createUnknown(javaClass.getClassName(), javaClass.getSourceFileName()); } else { return forEntireMethod(javaClass, m.getMethod()); } }