private String createUniqueStrForReference(Object reference) { String uniqueStr = null; if (reference instanceof TypeReference) { TypeReference type = (TypeReference) reference; String pathAndTypeStr = getPathAndTypeStr(type); if (pathAndTypeStr != null) { uniqueStr = "type|" + pathAndTypeStr; } } else if (reference instanceof MethodReference) { MethodReference method = (MethodReference) reference; String pathAndTypeStr = getPathAndTypeStr(method.getDeclaringType()); if (pathAndTypeStr != null) { uniqueStr = "method|" + pathAndTypeStr + "|" + method.getName() + "|" + method.getErasedSignature(); } } else if (reference instanceof FieldReference) { FieldReference field = (FieldReference) reference; String pathAndTypeStr = getPathAndTypeStr(field.getDeclaringType()); if (pathAndTypeStr != null) { uniqueStr = "field|" + pathAndTypeStr + "|" + field.getName(); } } return uniqueStr; }
private static String makeMethodKey(final MethodReference method) { return method.getFullName() + ":" + method.getErasedSignature(); } }
@Override public final String toString() { return _handleType + " " + _method.getFullName() + ":" + _method.getSignature(); } }
private boolean isRandomDouble(Node node) { if (Nodes.isInvoke(node)) { MethodReference mr = (MethodReference) ((Expression) node).getOperand(); if (mr.getSignature().equals("()D") && (Types.isRandomClass(mr.getDeclaringType()) && mr.getName().equals("nextDouble") || mr .getDeclaringType().getInternalName().equals("java/lang/Math") && mr.getName().equals("random"))) { return true; } } return false; } }
public static boolean knownToThrow(MethodReference mr) { if (mr.getName().startsWith("assert") || mr.getName().startsWith("require") || mr.getDeclaringType().getSimpleName().equals("Assert")) return true; if (Types.isBoxed(mr.getDeclaringType()) && mr.getName().startsWith("parse")) return true; return false; }
@SuppressWarnings("UnusedParameters") private List<Expression> adjustArgumentsForMethodCall(final MethodReference method, final List<Expression> arguments) { if (!arguments.isEmpty() && method.isConstructor()) { final TypeReference declaringType = method.getDeclaringType(); final MethodDefinition resolvedMethod = method.resolve(); method.getParameters().subList(start, end), arguments.subList(start, end) ); return adjustArgumentsForMethodCallCore(method.getParameters(), arguments);
private static ResolveResult resolveTypeFromMember(final MemberReference member) { if (member == null) { return null; } if (member instanceof FieldReference) { return new ResolveResult(((FieldReference) member).getFieldType()); } if (member instanceof MethodReference) { final MethodReference method = (MethodReference) member; if (method.isConstructor()) { return new ResolveResult(method.getDeclaringType()); } return new ResolveResult(method.getReturnType()); } return null; }
private static boolean isGetClassMethod(final MethodReference method) { return method.getParameters().isEmpty() && StringUtilities.equals(method.getName(), "getClass"); }
private boolean isCollectionStream(MethodReference mr) { return mr.getName().equals("stream") && mr.getParameters().isEmpty() && Types.isCollection(mr.getDeclaringType()); }
@Override public boolean containsGenericParameters() { if (super.containsGenericParameters() || hasGenericParameters()) { return true; } if (getReturnType().containsGenericParameters()) { return true; } if (hasParameters()) { final List<ParameterDefinition> parameters = getParameters(); for (int i = 0, n = parameters.size(); i < n; i++) { if (parameters.get(i).getParameterType().containsGenericParameters()) { return true; } } } return false; }
private boolean isCompare(Expression child) { if (child.getCode() == AstCode.InvokeVirtual || child.getCode() == AstCode.InvokeSpecial || child.getCode() == AstCode.InvokeInterface) { MethodReference mr = (MethodReference) child.getOperand(); if (mr.getReturnType().getSimpleType() == JvmType.Integer && ((mr.getName().equals("compare") && Types.isInstance(mr.getDeclaringType(), "java/util/Comparator")) || mr .getName().equals("compareTo"))) { return true; } } return false; } }
@Override public StringBuilder appendSignature(final StringBuilder sb) { final List<ParameterDefinition> parameters = getParameters(); StringBuilder s = sb; s.append('('); for (int i = 0, n = parameters.size(); i < n; ++i) { final ParameterDefinition p = parameters.get(i); s = p.getParameterType().appendSignature(s); } s.append(')'); s = getReturnType().appendSignature(s); return s; }
if(instr.getOpCode() == OpCode.INVOKESPECIAL) { MethodReference mr = instr.getOperand(0); if(mr.getDeclaringType().isEquivalentTo(ctor.getDeclaringType()) && mr.isConstructor()) { deps.put(ctor, mr.resolve());
@Override public MethodDefinition resolve() { return _genericDefinition.resolve(); }
final MethodReference method = (MethodReference) reference; if (method.isConstructor()) { final MethodDefinition resolvedMethod = method.resolve();
private static boolean isBufferedStream(Expression expr) { if (expr.getCode() == AstCode.InitObject) { MethodReference ctor = (MethodReference) expr.getOperand(); if (ctor.getDeclaringType().getInternalName().equals("java/io/BufferedOutputStream") && ctor.getSignature().equals("(Ljava/io/OutputStream;)V")) { return true; } } return false; }
private static boolean isFinalizer(MethodReference mr) { return mr.getName().equals("finalize") && mr.getSignature().equals("()V"); }
@Override public final String getName() { return _genericDefinition.getName(); } }
void checkOnlyOnce(Expression node, MethodContext ctx) { if (node.getCode() != AstCode.InvokeVirtual || node.getArguments().get(0).getCode() != AstCode.InitObject) return; MethodReference ctor = (MethodReference) node.getArguments().get(0).getOperand(); TypeReference type = ctor.getDeclaringType(); if (!Types.isRandomClass(type) || type.getInternalName().equals("java/security/SecureRandom")) return; MethodReference mr = (MethodReference) node.getOperand(); if(mr.getReturnType().getPackageName().equals("java.util.stream")) return; if(Inf.BACKLINK.findTransitiveUsages(node, true).allMatch(this::isRandomInit)) return; ctx.report("RandomUsedOnlyOnce", 0, node, RANDOM_TYPE.create(type)); }
public static MethodHandle getMethodHandle(DynamicCallSite dcs) { MethodHandle mh = dcs.getBootstrapMethodHandle(); if (mh.getMethod().getDeclaringType().getInternalName().equals("java/lang/invoke/LambdaMetafactory")) { List<Object> args = dcs.getBootstrapArguments(); if (args.size() > 1 && args.get(1) instanceof MethodHandle) { MethodHandle actualHandle = (MethodHandle) args.get(1); return actualHandle; } } return null; }