@Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null || getClass() != obj.getClass()) return false; SingleType other = (SingleType) obj; return what == other.what && tr.isEquivalentTo(other.tr); } }
@Override public boolean matches(final INode other, final Match match) { if (other instanceof AstType) { final TypeReference otherType = ((AstType) other).getUserData(Keys.TYPE_REFERENCE); return otherType != null && _type.isEquivalentTo(otherType); } return false; } }
private boolean anyIsString(final List<Expression> expressions) { final JavaResolver resolver = new JavaResolver(context); for (int i = 0; i < expressions.size(); i++) { final ResolveResult result = resolver.apply(expressions.get(i)); if (result != null && result.getType() != null && CommonTypeReferences.String.isEquivalentTo(result.getType())) { return true; } } return false; } }
private boolean anyIsString(final List<Expression> expressions) { final JavaResolver resolver = new JavaResolver(context); for (int i = 0; i < expressions.size(); i++) { final ResolveResult result = resolver.apply(expressions.get(i)); if (result != null && result.getType() != null && CommonTypeReferences.String.isEquivalentTo(result.getType())) { return true; } } return false; } }
private boolean anyIsString(final List<Expression> expressions) { final JavaResolver resolver = new JavaResolver(context); for (int i = 0; i < expressions.size(); i++) { final ResolveResult result = resolver.apply(expressions.get(i)); if (result != null && result.getType() != null && CommonTypeReferences.String.isEquivalentTo(result.getType())) { return true; } } return false; } }
static boolean isClassMethodCandidate(final MethodDefinition m) { return m != null && m.isSynthetic() && m.isStatic() && m.isPackagePrivate() && m.getParameters().size() == 1 && CommonTypeReferences.Class.isEquivalentTo(m.getReturnType()) && CommonTypeReferences.String.isEquivalentTo(m.getParameters().get(0).getParameterType()); }
if(instr.getOpCode() == OpCode.INVOKESPECIAL) { MethodReference mr = instr.getOperand(0); if(mr.getDeclaringType().isEquivalentTo(ctor.getDeclaringType()) && mr.isConstructor()) { deps.put(ctor, mr.resolve());
private boolean isStaticFieldAccess(Node n, TypeDefinition td) { if(!Nodes.isOp(n, AstCode.GetStatic) && !Nodes.isOp(n, AstCode.PutStatic)) return false; FieldReference fr = (FieldReference)((Expression)n).getOperand(); return fr.getDeclaringType().isEquivalentTo(td); } }
TypeReference type = ((MethodReference) expr.getOperand()).getDeclaringType(); List<WarningAnnotation<?>> annotations = usages.stream().filter( e -> isBoxing(e) && e.getInferredType().isEquivalentTo(arg.getInferredType())).map( e -> BOXED_AT.create(mc, e)).collect(Collectors.toList()); if (annotations.size() == usages.size()) {
public static TypeReference mergeTypes(TypeReference t1, TypeReference t2) { if (t1 == null || t2 == null) return null; if (t1 == BuiltinTypes.Null) return t2; if (t2 == BuiltinTypes.Null) return t1; if (t1.isEquivalentTo(t2)) return t1; if(t1.isArray() ^ t2.isArray()) return null; if(t1.isArray()) { TypeReference merged = mergeTypes(t1.getElementType(), t2.getElementType()); return merged == null ? null : merged.makeArrayType(); } List<TypeReference> chain1 = getBaseTypes(t1); List<TypeReference> chain2 = getBaseTypes(t2); for (int i = Math.min(chain1.size(), chain2.size()) - 1; i >= 0; i--) { if (chain1.get(i).equals(chain2.get(i))) return chain1.get(i); } return null; }
private Expression findOverloadCall(MethodDefinition md, Block block) { return (Expression)Nodes.find(block, node -> { if (Nodes.isOp(node, md.isConstructor() ? AstCode.InvokeSpecial : md.isStatic() ? AstCode.InvokeStatic : AstCode.InvokeVirtual)) { Expression expr = (Expression) node; MethodReference mr = (MethodReference) expr.getOperand(); if (mr.getDeclaringType().isEquivalentTo(md.getDeclaringType()) && mr.getName().equals(md.getName()) && !mr.getSignature().equals(md.getSignature())) { return true; } } return false; }); } }
public static MethodDefinition resolveToBridge(MethodDefinition md) { if (md.isBridgeMethod()) { return md; } for (MethodDefinition candidate : md.getDeclaringType().getDeclaredMethods()) { if (candidate.getName().equals(md.getName()) && candidate.isBridgeMethod()) { List<ParameterDefinition> params = candidate.getParameters(); if (params.size() == md.getParameters().size()) { MethodBody body = candidate.getBody(); if (body != null) { for (Instruction instr : body.getInstructions()) { if (instr.getOperandCount() == 1) { Object operand = instr.getOperand(0); if (operand instanceof MethodReference) { MethodReference mr = (MethodReference) operand; if (mr.getName().equals(md.getName()) && mr.getErasedSignature().equals(md .getErasedSignature()) && mr.getDeclaringType().isEquivalentTo(md .getDeclaringType())) { return candidate; } } } } } } } } return md; }
if (overloadMethod != null) { ParameterDefinition anotherParam = overloadMethod.getParameters().stream().filter(apd -> apd .getName().equals(pd.getName()) && apd.getParameterType().isEquivalentTo(pd .getParameterType())).findFirst().orElse(null); if (anotherParam != null) {
private static boolean isThisOrOuterThisReference(final Expression e) { if (e == null || e.isNull()) { return false; } if (e instanceof ThisReferenceExpression && ((ThisReferenceExpression) e).getTarget().isNull()) { return true; } if (e instanceof MemberReferenceExpression) { final MemberReference m = e.getUserData(Keys.MEMBER_REFERENCE); if (m instanceof FieldReference) { final FieldDefinition resolvedField = ((FieldReference) m).resolve(); if (resolvedField != null && resolvedField.isSynthetic() && resolvedField.getDeclaringType().isInnerClass() && resolvedField.getDeclaringType().getDeclaringType() != null && resolvedField.getDeclaringType().getDeclaringType().isEquivalentTo(resolvedField.getFieldType())) { return true; } } } return false; }
if (CommonTypeReferences.String.isEquivalentTo(leftResult.getType()) || CommonTypeReferences.String.isEquivalentTo(innerLeftResult.getType())) {
private static boolean equiLambdas(Lambda left, Lambda right, EquiContext ctx) { if(!equiMethods(left.getMethod(), right.getMethod()) || !equiTypes(left.getFunctionType(), right.getFunctionType())) return false; MethodDefinition leftMd = Nodes.getLambdaMethod(left); MethodDefinition rightMd = Nodes.getLambdaMethod(right); BiPredicate<Variable, Variable> curMatcher = ctx.varMatcher; ctx.varMatcher = (vl, vr) -> { if(curMatcher.test(vl, vr)) return true; VariableDefinition vlo = vl.getOriginalVariable(); VariableDefinition vro = vr.getOriginalVariable(); if(vlo != null && vro != null) { if(Variables.getMethodDefinition(vlo) == leftMd && Variables.getMethodDefinition(vro) == rightMd) { return vlo.getVariableType().isEquivalentTo(vro.getVariableType()) && vlo.getSlot() == vro.getSlot(); } } ParameterDefinition pl = vl.getOriginalParameter(); ParameterDefinition pr = vr.getOriginalParameter(); if(pl != null && pr != null && pl.getMethod() == leftMd && pr.getMethod() == rightMd) { return pl.getPosition() == pr.getPosition(); } return false; }; boolean result = equiBlocks(left.getBody(), right.getBody(), ctx); ctx.varMatcher = curMatcher; return result; }
final AstType type = first(match.<AstType>get("type")); if (signature.getReturnType().getElementType().isEquivalentTo(type.toTypeReference())) { final MethodGroupExpression replacement = new MethodGroupExpression( node.getOffset(),
final AstType type = first(match.<AstType>get("type")); if (signature.getReturnType().getElementType().isEquivalentTo(type.toTypeReference())) { final MethodGroupExpression replacement = new MethodGroupExpression( node.getOffset(),
final AstType type = first(match.<AstType>get("type")); if (signature.getReturnType().getElementType().isEquivalentTo(type.toTypeReference())) { final MethodGroupExpression replacement = new MethodGroupExpression( node.getOffset(),
leftResult.getType().isEquivalentTo(CommonTypeReferences.String)) {