lombok.ast.MethodInvocation Java Examples

@Override
public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
        @NonNull MethodInvocation node) {
    ResolvedNode resolved = context.resolve(node);

    if (!(resolved instanceof ResolvedMethod) ||
            !((ResolvedMethod) resolved).getContainingClass()
                    .isSubclassOf(PACKAGE_MANAGER_CLASS, false)) {
        return;
    }
    StrictListAccessor<Expression, MethodInvocation> argumentList = node.astArguments();

    // Ignore if the method doesn't fit our description.
    if (argumentList != null && argumentList.size() == 2) {
        TypeDescriptor firstParameterType = context.getType(argumentList.first());
        if (firstParameterType != null
            && firstParameterType.matchesSignature(JavaParser.TYPE_STRING)) {
            maybeReportIssue(calculateValue(context, argumentList.last()), context, node);
        }
    }
}
 

@Nullable
private static String getLhs(@NonNull MethodInvocation call) {
    Node parent = call.getParent();
    if (parent instanceof Cast) {
        parent = parent.getParent();
    }

    if (parent instanceof VariableDefinitionEntry) {
        VariableDefinitionEntry vde = (VariableDefinitionEntry) parent;
        return vde.astName().astValue();
    } else if (parent instanceof BinaryExpression) {
        BinaryExpression be = (BinaryExpression) parent;
        Expression left = be.astLeft();
        if (left instanceof VariableReference || left instanceof Select) {
            return be.astLeft().toString();
        } else if (left instanceof ArrayAccess) {
            ArrayAccess aa = (ArrayAccess) left;
            return aa.astOperand().toString();
        }
    }

    return null;
}
 

@Override
public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
        @NonNull MethodInvocation node) {

    // Call is only allowed if it is both only called on the super class (invoke special)
    // as well as within the same overriding method (e.g. you can't call super.onLayout
    // from the onMeasure method)
    Expression operand = node.astOperand();
    if (!(operand instanceof Super)) {
        report(context, node);
        return;
    }

    Node method = StringFormatDetector.getParentMethod(node);
    if (!(method instanceof MethodDeclaration) ||
            !((MethodDeclaration)method).astMethodName().astValue().equals(
                    node.astName().astValue())) {
        report(context, node);
    }
}
 

private static void report(JavaContext context, MethodInvocation node) {
    // Make sure the call is on a view
    JavaParser.ResolvedNode resolved = context.resolve(node);
    if (resolved instanceof JavaParser.ResolvedMethod) {
        JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolved;
        JavaParser.ResolvedClass containingClass = method.getContainingClass();
        if (!containingClass.isSubclassOf(CLASS_VIEW, false)) {
            return;
        }
    }

    String name = node.astName().astValue();
    String suggestion = Character.toLowerCase(name.charAt(2)) + name.substring(3);
    String message = String.format(
            // Keep in sync with {@link #getOldValue} and {@link #getNewValue} below!
            "Suspicious method call; should probably call \"`%1$s`\" rather than \"`%2$s`\"",
            suggestion, name);
    context.report(ISSUE, node, context.getLocation(node.astName()), message);
}
 

private static boolean isBeginTransaction(@NonNull JavaContext context,
        @NonNull MethodInvocation node) {
    String methodName = node.astName().astValue();
    assert methodName.equals(BEGIN_TRANSACTION) : methodName;
    if (BEGIN_TRANSACTION.equals(methodName)) {
        ResolvedNode resolved = context.resolve(node);
        if (resolved instanceof ResolvedMethod) {
            ResolvedMethod method = (ResolvedMethod) resolved;
            ResolvedClass containingClass = method.getContainingClass();
            if (containingClass.isSubclassOf(FRAGMENT_MANAGER_CLS, false)
                    || containingClass.isSubclassOf(FRAGMENT_MANAGER_V4_CLS,
                    false)) {
                return true;
            }
        }
    }

    return false;
}
 

@Override
public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
        @NonNull MethodInvocation node) {
    if (mDependsOnAppCompat && isAppBarActivityCall(context, node)) {
        String name = node.astName().astValue();
        String replace = null;
        if (GET_ACTION_BAR.equals(name)) {
            replace = "getSupportActionBar";
        } else if (START_ACTION_MODE.equals(name)) {
            replace = "startSupportActionMode";
        } else if (SET_PROGRESS_BAR_VIS.equals(name)) {
            replace = "setSupportProgressBarVisibility";
        } else if (SET_PROGRESS_BAR_IN_VIS.equals(name)) {
            replace = "setSupportProgressBarIndeterminateVisibility";
        } else if (SET_PROGRESS_BAR_INDETERMINATE.equals(name)) {
            replace = "setSupportProgressBarIndeterminate";
        } else if (REQUEST_WINDOW_FEATURE.equals(name)) {
            replace = "supportRequestWindowFeature";
        }

        if (replace != null) {
            String message = String.format(ERROR_MESSAGE_FORMAT, replace, name);
            context.report(ISSUE, node, context.getLocation(node), message);
        }
    }
}
 

private static boolean isAppBarActivityCall(@NonNull JavaContext context,
        @NonNull MethodInvocation node) {
    ResolvedNode resolved = context.resolve(node);
    if (resolved instanceof ResolvedMethod) {
        ResolvedMethod method = (ResolvedMethod) resolved;
        ResolvedClass containingClass = method.getContainingClass();
        if (containingClass.isSubclassOf(CLASS_ACTIVITY, false)) {
            // Make sure that the calling context is a subclass of ActionBarActivity;
            // we don't want to flag these calls if they are in non-appcompat activities
            // such as PreferenceActivity (see b.android.com/58512)
            ClassDeclaration surroundingClass = JavaContext.findSurroundingClass(node);
            if (surroundingClass != null) {
                ResolvedNode clz = context.resolve(surroundingClass);
                return clz instanceof ResolvedClass &&
                        ((ResolvedClass)clz).isSubclassOf(
                                "android.support.v7.app.ActionBarActivity",
                                false);
            }
        }
    }
    return false;
}
 

@Override
public void visitMethod(
        @NonNull JavaContext context,
        @Nullable AstVisitor visitor,
        @NonNull MethodInvocation node) {
    StrictListAccessor<Expression, MethodInvocation> argumentList = node.astArguments();
    if (argumentList != null && argumentList.size() == 1) {
        Expression argument = argumentList.first();
        if (argument instanceof Select) {
            String expression = argument.toString();
            if (expression.startsWith(R_LAYOUT_RESOURCE_PREFIX)) {
                whiteListLayout(expression.substring(R_LAYOUT_RESOURCE_PREFIX.length()));
            }
        }
    }
}
 

private static void ensureAtLeast(@NonNull JavaContext context,
        @NonNull MethodInvocation node, int parameter, long min) {
    Iterator<Expression> iterator = node.astArguments().iterator();
    Expression argument = null;
    for (int i = 0; i <= parameter; i++) {
        if (!iterator.hasNext()) {
            return;
        }
        argument = iterator.next();
    }
    if (argument == null) {
        return;
    }

    long value = getLongValue(context, argument);
    if (value < min) {
        String message = String.format("Value will be forced up to %d as of Android 5.1; "
                + "don't rely on this to be exact", min);
        context.report(ISSUE, argument, context.getLocation(argument), message);
    }
}
 

@Override
public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
        @NonNull MethodInvocation node) {
    assert node.astName().astValue().equals("sendTextMessage") ||  //$NON-NLS-1$
        node.astName().astValue().equals("sendMultipartTextMessage");  //$NON-NLS-1$
    if (node.astOperand() == null) {
        // "sendTextMessage"/"sendMultipartTextMessage" in the code with no operand
        return;
    }

    StrictListAccessor<Expression, MethodInvocation> args = node.astArguments();
    if (args.size() == 5) {
        Expression destinationAddress = args.first();
        if (destinationAddress instanceof StringLiteral) {
            String number = ((StringLiteral) destinationAddress).astValue();

            if (!number.startsWith("+")) {  //$NON-NLS-1$
               context.report(ISSUE, node, context.getLocation(destinationAddress),
                   "To make sure the SMS can be sent by all users, please start the SMS number " +
                   "with a + and a country code or restrict the code invocation to people in the country " +
                   "you are targeting.");
            }
        }
    }
}
 

@Override
public boolean visitMethodInvocation(MethodInvocation node) {
    if (node.astName().astValue().equals(SET_THEME)) {
        // Look at argument
        StrictListAccessor<Expression, MethodInvocation> args = node.astArguments();
        if (args.size() == 1) {
            Expression arg = args.first();
            if (arg instanceof Select) {
                String resource = arg.toString();
                if (resource.startsWith(R_STYLE_PREFIX)) {
                    if (mActivityToTheme == null) {
                        mActivityToTheme = new HashMap<String, String>();
                    }
                    String name = ((Select) arg).astIdentifier().astValue();
                    mActivityToTheme.put(mClassFqn, STYLE_RESOURCE_PREFIX + name);
                }
            }
        }
    }

    return false;
}
 

private static boolean checkWithinConditional(
        @NonNull JavaContext context,
        @Nullable Node curr,
        @NonNull MethodInvocation logCall) {
    while (curr != null) {
        if (curr instanceof If) {
            If ifNode = (If) curr;
            if (ifNode.astCondition() instanceof MethodInvocation) {
                MethodInvocation call = (MethodInvocation) ifNode.astCondition();
                if (IS_LOGGABLE.equals(call.astName().astValue())) {
                    checkTagConsistent(context, logCall, call);
                }
            }

            return true;
        } else if (curr instanceof MethodInvocation
                || curr instanceof ClassDeclaration) { // static block
            break;
        }
        curr = curr.getParent();
    }
    return false;
}
 

@Override
public boolean visitMethodInvocation(MethodInvocation node) {
    if (node == mTargetNode) {
        Expression arg = getTargetArgument();
        if (arg instanceof VariableReference) {
              VariableReference reference = (VariableReference) arg;
              String variable = reference.astIdentifier().astValue();
              mName = mMap.get(variable);
              mDone = true;
              return true;
        }
    }

    // Is this a getString() call? On a resource object? If so,
    // promote the resource argument up to the left hand side
    return super.visitMethodInvocation(node);
}
 

public Expression getArgument(int argument) {
    if (!(mTargetNode instanceof MethodInvocation)) {
        return null;
    }
    MethodInvocation call = (MethodInvocation) mTargetNode;
    StrictListAccessor<Expression, MethodInvocation> args = call.astArguments();
    if (argument >= args.size()) {
        return null;
    }

    Iterator<Expression> iterator = args.iterator();
    int index = 0;
    while (iterator.hasNext()) {
        Expression arg = iterator.next();
        if (index++ == argument) {
            return arg;
        }
    }

    return null;
}
 

private static boolean isCommittedInChainedCalls(@NonNull JavaContext context,
        @NonNull MethodInvocation node) {
    // Look for chained calls since the FragmentManager methods all return "this"
    // to allow constructor chaining, e.g.
    //    getFragmentManager().beginTransaction().addToBackStack("test")
    //            .disallowAddToBackStack().hide(mFragment2).setBreadCrumbShortTitle("test")
    //            .show(mFragment2).setCustomAnimations(0, 0).commit();
    Node parent = node.getParent();
    while (parent instanceof MethodInvocation) {
        MethodInvocation methodInvocation = (MethodInvocation) parent;
        if (isTransactionCommitMethodCall(context, methodInvocation)
                || isShowFragmentMethodCall(context, methodInvocation)) {
            return true;
        }

        parent = parent.getParent();
    }

    return false;
}
 

@Override
public AstVisitor createJavaVisitor(final JavaContext context) {
    return new ForwardingAstVisitor() {
        @Override
        public boolean visitMethodInvocation(MethodInvocation node) {
            JavaParser.ResolvedNode resolve = context.resolve(node);
            if (resolve instanceof JavaParser.ResolvedMethod) {
                JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolve;
                // 方法所在的类校验
                JavaParser.ResolvedClass containingClass = method.getContainingClass();
                if (containingClass.matches("android.util.Log")) {
                    context.report(ISSUE, node, context.getLocation(node),
                                   "请使用Ln，避免使用Log");
                    return true;
                }
                if (node.toString().startsWith("System.out.println")) {
                    context.report(ISSUE, node, context.getLocation(node),
                                   "请使用Ln，避免使用System.out.println");
                    return true;
                }
            }
            return super.visitMethodInvocation(node);
        }
    };
}
 

@Override
public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
                        @NonNull MethodInvocation node) {
    assert node.astName().astValue().equals("makeText");
    if (node.astOperand() == null) {
        // "makeText()" in the code with no operand
        return;
    }

    String operand = node.astOperand().toString();
    if (!(operand.equals("Toast") || operand.endsWith(".Toast"))) {
        return;
    }

    // Make sure you pass the right kind of duration: it's not a delay, it's
    //  LENGTH_SHORT or LENGTH_LONG
    // (see http://code.google.com/p/android/issues/detail?id=3655)
    StrictListAccessor<Expression, MethodInvocation> args = node.astArguments();
    if (args.size() == 3) {
        Expression duration = args.last();
        if (duration instanceof IntegralLiteral) {
            context.report(ISSUE, duration, context.getLocation(duration),
                    "Expected duration `Toast.LENGTH_SHORT` or `Toast.LENGTH_LONG`, a custom " +
                            "duration value is not supported");
        }
    }

    Node method = findSurroundingMethod(node.getParent());
    if (method == null) {
        return;
    }

    ShowFinder finder = new ShowFinder(node);
    method.accept(finder);
    if (!finder.isShowCalled()) {
        context.report(ISSUE, node, context.getLocation(node),
                "Toast created but not shown: did you forget to call `show()` ?");
    }
}
 

private boolean isInsideDialogFragment(JavaContext context, MethodInvocation node) {
    Node parent = node.getParent();
    while (parent != null) {
        Object resolvedNode = context.resolve(parent);
        if (resolvedNode instanceof JavaParser.ResolvedMethod) {
            JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolvedNode;
            if (isDialogFragment(method.getContainingClass())) {
                return true;
            }
        }
        parent = parent.getParent();
    }
    return false;
}
 

@Override
public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
        @NonNull MethodInvocation node) {

    String name = node.astName().astValue();
    if (BEGIN_TRANSACTION.equals(name)) {
        checkTransactionCommits(context, node);
    } else {
        checkResourceRecycled(context, node, name);
    }
}
 

@Override
public boolean visitMethodInvocation(MethodInvocation node) {
    System.out.println("ReceiverFinder::visitMethodInvocation " + node);
    if(node == this.mTarget) {
        this.mSeenTarget = true;
    } else if((this.mSeenTarget || node.astOperand() == this.mTarget) && "show".equals(node.astName().astValue())) {
        this.mFound = true;
    }

    return true;
}
 

@Override
public void visitMethod(JavaContext context, AstVisitor visitor, MethodInvocation node) {
    String name = node.astName().astValue();
    if (DISMISS.equals(name)) {
        checkUnsafeDismiss(context, node);
    } else {
        checkUnsafeCommit(context, node);
    }
}
 

@Override
public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
        @NonNull MethodInvocation node) {
    ResolvedNode resolved = context.resolve(node);
    if (!(resolved instanceof ResolvedMethod)) {
        return;
    }

    ResolvedMethod method = (ResolvedMethod) resolved;
    if (!method.getContainingClass().matches("android.database.sqlite.SQLiteDatabase")) {
        return;
    }

    // Try to resolve the String and look for STRING keys
    if (method.getArgumentCount() > 0
            && method.getArgumentType(0).matchesSignature(TYPE_STRING)
            && node.astArguments().size() == method.getArgumentCount()) {
        Iterator<Expression> iterator = node.astArguments().iterator();
        Node argument = iterator.next();
        String sql = ConstantEvaluator.evaluateString(context, argument, true);
        if (sql != null && (sql.startsWith("CREATE TABLE") || sql.startsWith("ALTER TABLE"))
                && sql.matches(".*\\bSTRING\\b.*")) {
            String message = "Using column type STRING; did you mean to use TEXT? "
                    + "(STRING is a numeric type and its value can be adjusted; for example,"
                    + "strings that look like integers can drop leading zeroes. See issue "
                    + "explanation for details.)";
            context.report(ISSUE, node, context.getLocation(node), message);
        }
    }
}
 

private static boolean isMethodOnFragmentClass(
        @NonNull JavaContext context,
        @NonNull MethodInvocation call,
        @NonNull String fragmentClass,
        @NonNull String v4FragmentClass) {
    ResolvedNode resolved = context.resolve(call);
    if (resolved instanceof ResolvedMethod) {
        ResolvedClass containingClass = ((ResolvedMethod) resolved).getContainingClass();
        return containingClass.isSubclassOf(fragmentClass, false) ||
                containingClass.isSubclassOf(v4FragmentClass, false);
    }

    return false;
}
 

@Override
public boolean visitMethodInvocation(MethodInvocation node) {
    if (node == mTarget) {
        mSeenTarget = true;
    } else if ((mSeenTarget || node.astOperand() == mTarget)
            && "show".equals(node.astName().astValue())) { //$NON-NLS-1$
        // TODO: Do more flow analysis to see whether we're really calling show
        // on the right type of object?
        mFound = true;
    }

    return true;
}
 

@Override
public boolean visitMethodInvocation(MethodInvocation node) {
    if (node == mTarget) {
        mSeenTarget = true;
    } else if ((mSeenTarget || node.astOperand() == mTarget)
            && "show".equals(node.astName().astValue())) { //$NON-NLS-1$
        // TODO: Do more flow analysis to see whether we're really calling show
        // on the right type of object?
        mFound = true;
    }

    return true;
}
 

private static boolean isTransactionCommitMethodCall(@NonNull JavaContext context,
        @NonNull MethodInvocation call) {

    String methodName = call.astName().astValue();
    return (COMMIT.equals(methodName) || COMMIT_ALLOWING_LOSS.equals(methodName)) &&
            isMethodOnFragmentClass(context, call,
                    FRAGMENT_TRANSACTION_CLS,
                    FRAGMENT_TRANSACTION_V4_CLS);
}
 

@Override
public List<Class<? extends Node>> getApplicableNodeTypes() {
    List<Class<? extends Node>> types = new ArrayList<Class<? extends Node>>(3);
    types.add(ConstructorInvocation.class);
    types.add(MethodDeclaration.class);
    types.add(MethodInvocation.class);
    return types;
}
 

private static boolean isSharedPreferenceGetString(@NonNull JavaContext context,
        @NonNull MethodInvocation call) {
    if (!GET_STRING_METHOD.equals(call.astName().astValue())) {
        return false;
    }

    JavaParser.ResolvedNode resolved = context.resolve(call);
    if (resolved instanceof JavaParser.ResolvedMethod) {
        JavaParser.ResolvedMethod resolvedMethod = (JavaParser.ResolvedMethod) resolved;
        JavaParser.ResolvedClass containingClass = resolvedMethod.getContainingClass();
        return containingClass.isSubclassOf(ANDROID_CONTENT_SHARED_PREFERENCES, false);
    }

    return false; // not certain
}
 

@Nullable
public static String getMethodName(@NonNull Node call) {
    if (call instanceof MethodInvocation) {
        return ((MethodInvocation)call).astName().astValue();
    } else if (call instanceof ConstructorInvocation) {
        return ((ConstructorInvocation)call).astTypeReference().getTypeName();
    } else if (call instanceof EnumConstant) {
        return ((EnumConstant)call).astName().astValue();
    } else {
        return null;
    }
}
 

@Override
public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
        @NonNull MethodInvocation node) {
    if (mFormatStrings == null && !context.getClient().supportsProjectResources()) {
        return;
    }

    String methodName = node.astName().astValue();
    if (methodName.equals(FORMAT_METHOD)) {
        // String.format(getResources().getString(R.string.foo), arg1, arg2, ...)
        // Check that the arguments in R.string.foo match arg1, arg2, ...
        if (node.astOperand() instanceof VariableReference) {
            VariableReference ref = (VariableReference) node.astOperand();
            if ("String".equals(ref.astIdentifier().astValue())) { //$NON-NLS-1$
                // Found a String.format call
                // Look inside to see if we can find an R string
                // Find surrounding method
                checkFormatCall(context, node);
            }
        }
    } else {
        // getResources().getString(R.string.foo, arg1, arg2, ...)
        // Check that the arguments in R.string.foo match arg1, arg2, ...
        if (node.astArguments().size() > 1 && node.astOperand() != null ) {
            checkFormatCall(context, node);
        }
    }
}