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 boolean highPriority(MethodReference mr) { return mr.getName().equals("asList") && mr.getDeclaringType().getInternalName().equals("java/util/Arrays") || mr.getName().equals("of") && mr.getDeclaringType().getInternalName().equals("java/util/stream/Stream"); } }
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; }
@Override protected StringBuilder appendName(final StringBuilder sb, final boolean fullName, final boolean dottedName) { if (fullName) { final TypeReference declaringType = getDeclaringType(); if (declaringType != null) { return declaringType.appendName(sb, true, false).append('.').append(getName()); } } return sb.append(getName()); }
@Override protected StringBuilder appendName(final StringBuilder sb, final boolean fullName, final boolean dottedName) { if (fullName) { final TypeReference declaringType = getDeclaringType(); if (declaringType != null) { return declaringType.appendName(sb, true, false).append('.').append(getName()); } } return sb.append(getName()); }
@Override protected StringBuilder appendName(final StringBuilder sb, final boolean fullName, final boolean dottedName) { if (fullName) { final TypeReference declaringType = getDeclaringType(); if (declaringType != null) { return declaringType.appendName(sb, true, false).append('.').append(getName()); } } return sb.append(getName()); }
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; }
public MethodDefinition resolve() { final TypeReference declaringType = getDeclaringType(); if (declaringType == null) throw ContractUtils.unsupported(); return declaringType.resolve(this); }
public MethodDefinition resolve() { final TypeReference declaringType = getDeclaringType(); if (declaringType == null) throw ContractUtils.unsupported(); return declaringType.resolve(this); }
public MethodDefinition resolve() { final TypeReference declaringType = getDeclaringType(); if (declaringType == null) throw ContractUtils.unsupported(); return declaringType.resolve(this); }
private boolean isStreamForEach(MethodReference mr) { return (mr.getName().equals("forEach") || mr.getName().equals("forEachOrdered")) && mr.getErasedSignature().equals("(Ljava/util/function/Consumer;)V") && Types.isStream(mr.getDeclaringType()); }
private boolean isRandomInit(Expression expr) { if(expr.getCode() == AstCode.InitObject) { MethodReference ctor = (MethodReference) expr.getOperand(); // It seems ok to initialize cern.jet.random generators with new Random().nextInt() if(ctor.getDeclaringType().getPackageName().equals("cern.jet.random.engine")) return true; } return false; }
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 boolean isStreamFilter(MethodReference mr) { if(!mr.getName().equals("filter") || mr.getParameters().size() != 1) return false; TypeReference type = mr.getParameters().get(0).getParameterType(); return type.getSimpleName().endsWith("Predicate") && type.getPackageName().equals("java.util.function") && Types.isBaseStream(mr.getDeclaringType()); } }
private boolean isBoxedToString(Expression expr) { if (expr.getCode() == AstCode.InvokeVirtual) { MethodReference mr = (MethodReference) expr.getOperand(); if (mr.getName().equals("toString") && mr.getSignature().equals("()Ljava/lang/String;")) { TypeReference type = mr.getDeclaringType(); if (Types.isBoxed(type)) { return true; } } } return false; }
private static boolean isClassGetName(Expression expr) { if (expr.getCode() == AstCode.InvokeVirtual) { MethodReference mr = (MethodReference) expr.getOperand(); if (mr.getName().equals("getName") && Types.is(mr.getDeclaringType(), Class.class)) return true; } return false; }
@Override public MethodDefinition resolve(final MethodReference method) { TypeReference declaringType = VerifyArgument.notNull(method, "method").getDeclaringType(); if (declaringType.isArray()) { declaringType = BuiltinTypes.Object; } final TypeDefinition resolvedDeclaringType = declaringType.resolve(); if (resolvedDeclaringType == null) { return null; } return getMethod(resolvedDeclaringType, method); }
@AstVisitor(nodes=AstNodes.EXPRESSIONS) public void visit(Expression node, MethodContext ctx) { if(node.getCode() == AstCode.InvokeVirtual) { MethodReference ref = (MethodReference) node.getOperand(); if (Methods.isGetClass(ref) && node.getArguments().get(0).getCode() == AstCode.InitObject) { ctx.report("NewForGetClass", 0, node, OBJECT_TYPE.create(ref.getDeclaringType())); } } } }
public static void writeMethod(final ITextOutput writer, final MethodReference method) { VerifyArgument.notNull(method, "method"); VerifyArgument.notNull(writer, "writer"); final Stack<TypeReference> typeStack = new Stack<>(); formatType(writer, method.getDeclaringType(), NameSyntax.DESCRIPTOR, false, typeStack); writer.writeDelimiter("."); writer.writeReference(method.getName(), method); writer.writeDelimiter(":"); formatMethodSignature(writer, method, typeStack); }
public static void writeMethod(final ITextOutput writer, final MethodReference method) { VerifyArgument.notNull(method, "method"); VerifyArgument.notNull(writer, "writer"); final Stack<TypeReference> typeStack = new Stack<>(); formatType(writer, method.getDeclaringType(), NameSyntax.DESCRIPTOR, false, typeStack); writer.writeDelimiter("."); writer.writeReference(method.getName(), method); writer.writeDelimiter(":"); formatMethodSignature(writer, method, typeStack); }