import lombok.ast.Node; //导入依赖的package包/类
@Override
public void visitMethod(JavaContext context, AstVisitor visitor, MethodInvocation node) {
    if (!isNode(context, node, MethodDefinitions.ALL_OF)) {
        return;
    }
    // is parent onView or withView?
    Node parentNode = node.getParent();
    if (isInvalidParent(context, parentNode)) {
        return;
    }

    MethodInvocation matcher = extractMatcher(context, node);
    // has withXXX()
    if (!isWithNode(context, matcher)) {
        return;
    }
    String message = argumentsAsString(matcher, MESSAGE_FORMAT);
    context.report(ISSUE, node, context.getLocation(parentNode), message);
}
 

import lombok.ast.Node; //导入依赖的package包/类
@Override
public boolean visitAnnotation(Annotation node) {
  String type = node.astAnnotationTypeReference().getTypeName();
  if (DAGGER_MODULE.equals(type)) {
    Node parent = node.getParent();
    if (parent instanceof Modifiers) {
      parent = parent.getParent();
      if (parent instanceof ClassDeclaration) {
        int flags = ((ClassDeclaration) parent).astModifiers().getEffectiveModifierFlags();
        if ((flags & Modifier.ABSTRACT) == 0) {
          context.report(ISSUE, Location.create(context.file), ISSUE.getBriefDescription(TextFormat.TEXT));
        }
      }
    }
  }

  return super.visitAnnotation(node);
}
 

import lombok.ast.Node; //导入依赖的package包/类
@Override
public void visitResourceReference(
        @NonNull JavaContext context,
        @Nullable AstVisitor visitor,
        @NonNull Node node,
        @NonNull String type,
        @NonNull String name,
        boolean isFramework) {
    if (context.getProject().isGradleProject() && !isFramework) {
        Project project = context.getProject();
        if (project.getGradleProjectModel() != null && project.getCurrentVariant() != null) {
            ResourceType resourceType = ResourceType.getEnum(type);
            if (resourceType != null && isPrivate(context, resourceType, name)) {
                String message = createUsageErrorMessage(context, resourceType, name);
                context.report(ISSUE, node, context.getLocation(node), message);
            }
        }
    }
}
 

import lombok.ast.Node; //导入依赖的package包/类
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;
}
 

import lombok.ast.Node; //导入依赖的package包/类
public static Node findNodeByLiterals(Node root, Class<?> targetNodeClass, String literals) {
    if (null == root || null == targetNodeClass) {
        return null;
    }

    if (root.getClass().equals(targetNodeClass) &&
            root.toString().equals(literals)) {
        return root;
    }

    Node ret = null;
    for (Node child : root.getChildren()) {
        ret = findNodeByLiterals(child, targetNodeClass, literals);
        if (null != ret) {
            break;
        }
    }
    return ret;
}
 

import lombok.ast.Node; //导入依赖的package包/类
/**
 * 给定thread变量名，获取其所有的setPriority()节点列表
 *
 * @param operand
 * @param node
 * @param setPriorityNodes
 */
private void searchSetPriorityNodes(Node operand, Node node, ArrayList<MethodInvocation> setPriorityNodes) {
    JavaParser.ResolvedMethod resolvedMethod = NodeUtils.parseResolvedMethod(mContext, node);
    if (null != resolvedMethod &&
            "setPriority".equals(resolvedMethod.getName()) &&
            resolvedMethod.getContainingClass().isSubclassOf("java.lang.Thread", false) &&
            node instanceof MethodInvocation) {
        MethodInvocation methodInvocation = (MethodInvocation)node;
        // 这里比较的是Node.toString()而非Node本身，原因在于，赋值节点的operand是Identifier，
        // 而此处Thread.setPriority()节点的operand确实VariableReference。虽然它们的字符串值
        // 相同，但是在AST里却是不同类型的节点。
        if (methodInvocation.rawOperand().toString().equals(operand.toString())) {
            setPriorityNodes.add(methodInvocation);
        }
    }

    List<Node> children = node.getChildren();
    if (null != children && !children.isEmpty()) {
        for (Node child : node.getChildren()) {
            searchSetPriorityNodes(operand, child, setPriorityNodes);
        }
    }
}
 

import lombok.ast.Node; //导入依赖的package包/类
@Nullable
@Override
public ResolvedNode resolve(@NonNull JavaContext context, @NonNull Node node) {
  final PsiElement element = getPsiElement(node);
  if (element == null) {
    return null;
  }

  Application application = ApplicationManager.getApplication();
  if (application.isReadAccessAllowed()) {
    return resolve(element);
  }
  return application.runReadAction(new Computable<ResolvedNode>() {
    @Nullable
    @Override
    public ResolvedNode compute() {
      return resolve(element);
    }
  });
}
 

import lombok.ast.Node; //导入依赖的package包/类
/**
 * If setContentView is called by 'this' instance,
 * this method will check if 'this' is an instance of a Class inherit from android.app.Activity, for eaxmple AppCompatActivity or FragmentActivity, and so on.
 */
private boolean isThisInstanceOfActivity_ForActivity(@NonNull JavaContext context, @NonNull MethodInvocation node) {
    Node currentNode = node.getParent();

    JavaParser.ResolvedNode resolved = context.resolve(JavaContext.findSurroundingClass(node));
    JavaParser.ResolvedClass sorroundingClass = (JavaParser.ResolvedClass) resolved;
    while (sorroundingClass != null) {
        //System.out.println("sorroundingClass = " + sorroundingClass);
        if ("android.app.Activity".equals(sorroundingClass.getName())) {
            return true;
        } else {
            sorroundingClass = sorroundingClass.getSuperClass();
        }
    }


    return false;


}
 

import lombok.ast.Node; //导入依赖的package包/类
@Override
public void checkClass(@NonNull JavaContext context, @Nullable ClassDeclaration declaration,
        @NonNull Node node, @NonNull ResolvedClass cls) {
    if (!isInnerClass(declaration)) {
        return;
    }

    if (isStaticClass(declaration)) {
        return;
    }

    // Only flag handlers using the default looper
    if (hasLooperConstructorParameter(cls)) {
        return;
    }

    Node locationNode = node instanceof ClassDeclaration
            ? ((ClassDeclaration) node).astName() : node;
    Location location = context.getLocation(locationNode);
    context.report(ISSUE, location, String.format(
            "This Handler class should be static or leaks might occur (%1$s)",
            cls.getName()));
}
 

import lombok.ast.Node; //导入依赖的package包/类
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;
}
 

import lombok.ast.Node; //导入依赖的package包/类
@Nullable
private static Node parse(String code) {
  CompilerOptions options = new CompilerOptions();
  options.complianceLevel = options.sourceLevel = options.targetJDK = ClassFileConstants.JDK1_7;
  options.parseLiteralExpressionsAsConstants = true;
  ProblemReporter problemReporter = new ProblemReporter(
    DefaultErrorHandlingPolicies.exitOnFirstError(), options, new DefaultProblemFactory());
  Parser parser = new Parser(problemReporter, options.parseLiteralExpressionsAsConstants);
  parser.javadocParser.checkDocComment = false;
  EcjTreeConverter converter = new EcjTreeConverter();
  org.eclipse.jdt.internal.compiler.batch.CompilationUnit sourceUnit =
    new org.eclipse.jdt.internal.compiler.batch.CompilationUnit(code.toCharArray(), "unitTest", "UTF-8");
  CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
  CompilationUnitDeclaration unit = parser.parse(sourceUnit, compilationResult);
  if (unit == null) {
    return null;
  }
  converter.visit(code, unit);
  List<? extends Node> nodes = converter.getAll();
  for (lombok.ast.Node node : nodes) {
    if (node instanceof lombok.ast.CompilationUnit) {
      return node;
    }
  }
  return null;
}
 

import lombok.ast.Node; //导入依赖的package包/类
/**
 * Returns the first ancestor node of the given type
 *
 * @param element the element to search from
 * @param clz     the target node type
 * @param strict  if true, do not consider the element itself, only its parents
 * @param <T>     the target node type
 * @return the nearest ancestor node in the parent chain, or null if not found
 */
@Nullable
public static <T extends Node> T getParentOfType(
        @Nullable Node element,
        @NonNull Class<T> clz,
        boolean strict) {
    if (element == null) {
        return null;
    }

    if (strict) {
        element = element.getParent();
    }

    while (element != null) {
        if (clz.isInstance(element)) {
            //noinspection unchecked
            return (T) element;
        }
        element = element.getParent();
    }

    return null;
}
 

import lombok.ast.Node; //导入依赖的package包/类
@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);
    }
}
 

import lombok.ast.Node; //导入依赖的package包/类
private static void checkColor(@NonNull JavaContext context, @NonNull Node argument) {
    if (argument instanceof InlineIfExpression) {
        InlineIfExpression expression = (InlineIfExpression) argument;
        checkColor(context, expression.astIfTrue());
        checkColor(context, expression.astIfFalse());
        return;
    }

    List<ResourceType> types = getResourceTypes(context, argument);

    if (types != null && types.contains(ResourceType.COLOR)) {
        String message = String.format(
                "Should pass resolved color instead of resource id here: " +
                        "`getResources().getColor(%1$s)`", argument.toString());
        context.report(COLOR_USAGE, argument, context.getLocation(argument), message);
    }
}
 

import lombok.ast.Node; //导入依赖的package包/类
@Nullable
private static VariableDefinition getLhs(@NonNull Node node) {
    while (node != null) {
        Class<? extends Node> type = node.getClass();
        // The Lombok AST uses a flat hierarchy of node type implementation classes
        // so no need to do instanceof stuff here.
        if (type == MethodDeclaration.class || type == ConstructorDeclaration.class) {
            return null;
        }
        if (type == VariableDefinition.class) {
            return (VariableDefinition) node;
        }

        node = node.getParent();
    }

    return null;
}
 

import lombok.ast.Node; //导入依赖的package包/类
private static void checkIntRange(
        @NonNull JavaContext context,
        @NonNull ResolvedAnnotation annotation,
        @NonNull Node argument) {
    Object object = ConstantEvaluator.evaluate(context, argument);
    if (!(object instanceof Number)) {
        return;
    }
    long value = ((Number)object).longValue();
    long from = getLongAttribute(annotation, ATTR_FROM, Long.MIN_VALUE);
    long to = getLongAttribute(annotation, ATTR_TO, Long.MAX_VALUE);

    String message = getIntRangeError(value, from, to);
    if (message != null) {
        context.report(RANGE, argument, context.getLocation(argument), message);
    }
}
 

import lombok.ast.Node; //导入依赖的package包/类
private static void checkFloatRange(
        @NonNull JavaContext context,
        @NonNull ResolvedAnnotation annotation,
        @NonNull Node argument) {
    Object object = ConstantEvaluator.evaluate(context, argument);
    if (!(object instanceof Number)) {
        return;
    }
    double value = ((Number)object).doubleValue();
    double from = getDoubleAttribute(annotation, ATTR_FROM, Double.NEGATIVE_INFINITY);
    double to = getDoubleAttribute(annotation, ATTR_TO, Double.POSITIVE_INFINITY);
    boolean fromInclusive = getBoolean(annotation, ATTR_FROM_INCLUSIVE, true);
    boolean toInclusive = getBoolean(annotation, ATTR_TO_INCLUSIVE, true);

    String message = getFloatRangeError(value, from, to, fromInclusive, toInclusive, argument);
    if (message != null) {
        context.report(RANGE, argument, context.getLocation(argument), message);
    }
}
 

import lombok.ast.Node; //导入依赖的package包/类
@Override
public void checkClass(@NonNull JavaContext context, @Nullable ClassDeclaration node,
        @NonNull Node declarationOrAnonymous, @NonNull ResolvedClass resolvedClass) {
    if (!context.getProject().getReportIssues()) {
        return;
    }
    String className = resolvedClass.getName();
    if (resolvedClass.isSubclassOf(PREFERENCE_ACTIVITY, false)
            && mExportedActivities.containsKey(className)) {

        // Ignore the issue if we target an API greater than 19 and the class in
        // question specifically overrides isValidFragment() and thus knowingly white-lists
        // valid fragments.
        if (context.getMainProject().getTargetSdk() >= 19
                && overridesIsValidFragment(resolvedClass)) {
            return;
        }

        String message = String.format(
                "`PreferenceActivity` subclass `%1$s` should not be exported",
                className);
        context.report(ISSUE, mExportedActivities.get(className).resolve(), message);
    }
}
 

import lombok.ast.Node; //导入依赖的package包/类
private boolean isInvalidParent(JavaContext context, Node parentNode) {
    if (!(parentNode instanceof MethodInvocation)) {
        return true;
    }
    MethodInvocation parent = (MethodInvocation) parentNode;
    return !isNode(context, parent, MethodDefinitions.RISTRETTO_WITH_VIEW)
            && !isNode(context, parent, MethodDefinitions.ON_VIEW);
}
 

import lombok.ast.Node; //导入依赖的package包/类
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;
}