public void sawSuperCall(XMethod from, XMethod constructorInSuperClass) { if (constructorInSuperClass == null || from == null) { return; } if ("()V".equals(constructorInSuperClass.getSignature())) { return; } nonVoidSuperConstructorsCalled.put(from, constructorInSuperClass); }
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 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;"); }
public static boolean confusingMethodNamesWrongPackage(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.getSignature().equals(m2.getSignature())) { return false; } if (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 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; }
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; }
/** * 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()); }
/** * @param result * @param m */ public static void addKnownTypeQualifiersForParameters(HashSet<? super TypeQualifierValue<?>> result, XMethod m) { int numParameters = new SignatureParser(m.getSignature()).getNumParameters(); for (int p = 0; p < numParameters; p++) { addKnownTypeQualifiers(result, TypeQualifierApplications.getApplicableApplications(m, p)); } }
/** * 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 boolean visitClass(ClassDescriptor classDescriptor, XClass xclass) { assert xclass != null; String methodSignature = xmethod.getSignature(); XMethod bridgedFrom = xmethod.bridgeFrom(); // See if this class has an overridden method XMethod xm = xclass.findMethod(xmethod.getName(), methodSignature, false); if (xm == null && bridgedFrom != null && !classDescriptor.equals(xmethod.getClassDescriptor())) { methodSignature = bridgedFrom.getSignature(); xm = xclass.findMethod(xmethod.getName(), methodSignature, false); } if (xm != null) { return visitOverriddenMethod(xm) || bridgedFrom != null; } else { // Even though this particular class doesn't contain the method // we're // looking for, a superclass might, so we need to keep going. return true; } }
@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); }
/** * Constructor. Creates an entry which matches the given XMethod. * * @param xmethod * an XMethod * @param action * ActionType (ADD or DEL, depending on whether obligation is * added or deleted) * @param entryType * entry type * @param obligations * Obligation to be added or deleted */ public MatchMethodEntry(XMethod xmethod, ObligationPolicyDatabaseActionType action, ObligationPolicyDatabaseEntryType entryType, Obligation... obligations) { this(new SubtypeTypeMatcher(xmethod.getClassDescriptor()), new ExactStringMatcher(xmethod.getName()), new ExactStringMatcher(xmethod.getSignature()), xmethod.isStatic(), action, entryType, obligations); }
/** * 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()); } }
private void registerParameterSources() { ValueNumberFrame vnaFrameAtEntry = vnaDataflow.getStartFact(cfg.getEntry()); SignatureParser sigParser = new SignatureParser(xmethod.getSignature()); int firstParamSlot = xmethod.isStatic() ? 0 : 1; int param = 0; int slotOffset = 0; for ( String paramSig : sigParser.parameterSignatures()) { // Get the TypeQualifierAnnotation for this parameter SourceSinkInfo info; TypeQualifierAnnotation tqa = TypeQualifierApplications.getEffectiveTypeQualifierAnnotation(xmethod, param, typeQualifierValue); When when = (tqa != null) ? tqa.when : When.UNKNOWN; ValueNumber vn = vnaFrameAtEntry.getValue(slotOffset + firstParamSlot); info = new SourceSinkInfo(SourceSinkType.PARAMETER, cfg.getLocationAtEntry(), vn, when); info.setParameterAndLocal(param, slotOffset + firstParamSlot); registerSourceSink(info); param++; slotOffset += SignatureParser.getNumSlotsForType(paramSig); } }