/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.tools.lint.checks;
import static com.android.SdkConstants.ANDROID_URI;
import static com.android.SdkConstants.ATTR_NAME;
import static com.android.SdkConstants.ATTR_VALUE;
import static com.android.SdkConstants.CLASS_INTENT;
import static com.android.SdkConstants.INT_DEF_ANNOTATION;
import static com.android.SdkConstants.R_CLASS;
import static com.android.SdkConstants.STRING_DEF_ANNOTATION;
import static com.android.SdkConstants.SUPPORT_ANNOTATIONS_PREFIX;
import static com.android.SdkConstants.TAG_PERMISSION;
import static com.android.SdkConstants.TAG_USES_PERMISSION;
import static com.android.SdkConstants.TYPE_DEF_FLAG_ATTRIBUTE;
import static com.android.resources.ResourceType.COLOR;
import static com.android.resources.ResourceType.DRAWABLE;
import static com.android.resources.ResourceType.MIPMAP;
import static com.android.tools.lint.checks.PermissionFinder.Operation.ACTION;
import static com.android.tools.lint.checks.PermissionFinder.Operation.READ;
import static com.android.tools.lint.checks.PermissionFinder.Operation.WRITE;
import static com.android.tools.lint.checks.PermissionRequirement.ATTR_PROTECTION_LEVEL;
import static com.android.tools.lint.checks.PermissionRequirement.VALUE_DANGEROUS;
import static com.android.tools.lint.detector.api.JavaContext.findSurroundingMethod;
import static com.android.tools.lint.detector.api.JavaContext.getParentOfType;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.resources.ResourceType;
import com.android.sdklib.AndroidVersion;
import com.android.tools.lint.checks.PermissionFinder.Operation;
import com.android.tools.lint.checks.PermissionFinder.Result;
import com.android.tools.lint.checks.PermissionHolder.SetPermissionLookup;
import com.android.tools.lint.client.api.JavaParser.ResolvedAnnotation;
import com.android.tools.lint.client.api.JavaParser.ResolvedClass;
import com.android.tools.lint.client.api.JavaParser.ResolvedField;
import com.android.tools.lint.client.api.JavaParser.ResolvedMethod;
import com.android.tools.lint.client.api.JavaParser.ResolvedNode;
import com.android.tools.lint.client.api.JavaParser.TypeDescriptor;
import com.android.tools.lint.client.api.LintClient;
import com.android.tools.lint.detector.api.Category;
import com.android.tools.lint.detector.api.ConstantEvaluator;
import com.android.tools.lint.detector.api.Detector;
import com.android.tools.lint.detector.api.Implementation;
import com.android.tools.lint.detector.api.Issue;
import com.android.tools.lint.detector.api.JavaContext;
import com.android.tools.lint.detector.api.Project;
import com.android.tools.lint.detector.api.Scope;
import com.android.tools.lint.detector.api.Severity;
import com.android.utils.XmlUtils;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Set;
import lombok.ast.ArrayCreation;
import lombok.ast.ArrayInitializer;
import lombok.ast.AstVisitor;
import lombok.ast.BinaryExpression;
import lombok.ast.BinaryOperator;
import lombok.ast.Catch;
import lombok.ast.ConstructorInvocation;
import lombok.ast.EnumConstant;
import lombok.ast.Expression;
import lombok.ast.ExpressionStatement;
import lombok.ast.FloatingPointLiteral;
import lombok.ast.ForwardingAstVisitor;
import lombok.ast.InlineIfExpression;
import lombok.ast.IntegralLiteral;
import lombok.ast.MethodDeclaration;
import lombok.ast.MethodInvocation;
import lombok.ast.Node;
import lombok.ast.NullLiteral;
import lombok.ast.Select;
import lombok.ast.Statement;
import lombok.ast.StringLiteral;
import lombok.ast.Try;
import lombok.ast.TypeReference;
import lombok.ast.UnaryExpression;
import lombok.ast.UnaryOperator;
import lombok.ast.VariableDeclaration;
import lombok.ast.VariableDefinition;
import lombok.ast.VariableDefinitionEntry;
import lombok.ast.VariableReference;
/**
* Looks up annotations on method calls and enforces the various things they
* express, e.g. for {@code @CheckReturn} it makes sure the return value is used,
* for {@code ColorInt} it ensures that a proper color integer is passed in, etc.
*
* TODO: Throw in some annotation usage checks here too; e.g. specifying @Size without parameters,
* specifying toInclusive without setting to, combining @ColorInt with any @ResourceTypeRes,
* using @CheckResult on a void method, etc.
*/
public class SupportAnnotationDetector extends Detector implements Detector.JavaScanner {
public static final Implementation IMPLEMENTATION
= new Implementation(SupportAnnotationDetector.class, Scope.JAVA_FILE_SCOPE);
/** Method result should be used */
public static final Issue RANGE = Issue.create(
"Range", //$NON-NLS-1$
"Outside Range",
"Some parameters are required to in a particular numerical range; this check " +
"makes sure that arguments passed fall within the range. For arrays, Strings " +
"and collections this refers to the size or length.",
Category.CORRECTNESS,
6,
Severity.ERROR,
IMPLEMENTATION);
/**
* Attempting to set a resource id as a color
*/
public static final Issue RESOURCE_TYPE = Issue.create(
"ResourceType", //$NON-NLS-1$
"Wrong Resource Type",
"Ensures that resource id's passed to APIs are of the right type; for example, " +
"calling `Resources.getColor(R.string.name)` is wrong.",
Category.CORRECTNESS,
7,
Severity.FATAL,
IMPLEMENTATION);
/** Attempting to set a resource id as a color */
public static final Issue COLOR_USAGE = Issue.create(
"ResourceAsColor", //$NON-NLS-1$
"Should pass resolved color instead of resource id",
"Methods that take a color in the form of an integer should be passed " +
"an RGB triple, not the actual color resource id. You must call " +
"`getResources().getColor(resource)` to resolve the actual color value first.",
Category.CORRECTNESS,
7,
Severity.ERROR,
IMPLEMENTATION);
/** Passing the wrong constant to an int or String method */
public static final Issue TYPE_DEF = Issue.create(
"WrongConstant", //$NON-NLS-1$
"Incorrect constant",
"Ensures that when parameter in a method only allows a specific set " +
"of constants, calls obey those rules.",
Category.SECURITY,
6,
Severity.ERROR,
IMPLEMENTATION);
/** Method result should be used */
public static final Issue CHECK_RESULT = Issue.create(
"CheckResult", //$NON-NLS-1$
"Ignoring results",
"Some methods have no side effects, an calling them without doing something " +
"without the result is suspicious. ",
Category.CORRECTNESS,
6,
Severity.WARNING,
IMPLEMENTATION);
/** Failing to enforce security by just calling check permission */
public static final Issue CHECK_PERMISSION = Issue.create(
"UseCheckPermission", //$NON-NLS-1$
"Using the result of check permission calls",
"You normally want to use the result of checking a permission; these methods " +
"return whether the permission is held; they do not throw an error if the permission " +
"is not granted. Code which does not do anything with the return value probably " +
"meant to be calling the enforce methods instead, e.g. rather than " +
"`Context#checkCallingPermission` it should call `Context#enforceCallingPermission`.",
Category.SECURITY,
6,
Severity.WARNING,
IMPLEMENTATION);
/** Method result should be used */
public static final Issue MISSING_PERMISSION = Issue.create(
"MissingPermission", //$NON-NLS-1$
"Missing Permissions",
"This check scans through your code and libraries and looks at the APIs being used, " +
"and checks this against the set of permissions required to access those APIs. If " +
"the code using those APIs is called at runtime, then the program will crash.\n" +
"\n" +
"Furthermore, for permissions that are revocable (with targetSdkVersion 23), client " +
"code must also be prepared to handle the calls throwing an exception if the user " +
"rejects the request for permission at runtime.",
Category.CORRECTNESS,
9,
Severity.ERROR,
IMPLEMENTATION);
/** Passing the wrong constant to an int or String method */
public static final Issue THREAD = Issue.create(
"WrongThread", //$NON-NLS-1$
"Wrong Thread",
"Ensures that a method which expects to be called on a specific thread, is actually " +
"called from that thread. For example, calls on methods in widgets should always " +
"be made on the UI thread.",
Category.CORRECTNESS,
6,
Severity.ERROR,
IMPLEMENTATION)
.addMoreInfo(
"http://developer.android.com/guide/components/processes-and-threads.html#Threads");
public static final String CHECK_RESULT_ANNOTATION = SUPPORT_ANNOTATIONS_PREFIX + "CheckResult"; //$NON-NLS-1$
public static final String COLOR_INT_ANNOTATION = SUPPORT_ANNOTATIONS_PREFIX + "ColorInt"; //$NON-NLS-1$
public static final String INT_RANGE_ANNOTATION = SUPPORT_ANNOTATIONS_PREFIX + "IntRange"; //$NON-NLS-1$
public static final String FLOAT_RANGE_ANNOTATION = SUPPORT_ANNOTATIONS_PREFIX + "FloatRange"; //$NON-NLS-1$
public static final String SIZE_ANNOTATION = SUPPORT_ANNOTATIONS_PREFIX + "Size"; //$NON-NLS-1$
public static final String PERMISSION_ANNOTATION = SUPPORT_ANNOTATIONS_PREFIX + "RequiresPermission"; //$NON-NLS-1$
public static final String UI_THREAD_ANNOTATION = SUPPORT_ANNOTATIONS_PREFIX + "UiThread"; //$NON-NLS-1$
public static final String MAIN_THREAD_ANNOTATION = SUPPORT_ANNOTATIONS_PREFIX + "MainThread"; //$NON-NLS-1$
public static final String WORKER_THREAD_ANNOTATION = SUPPORT_ANNOTATIONS_PREFIX + "WorkerThread"; //$NON-NLS-1$
public static final String BINDER_THREAD_ANNOTATION = SUPPORT_ANNOTATIONS_PREFIX + "BinderThread"; //$NON-NLS-1$
public static final String PERMISSION_ANNOTATION_READ = PERMISSION_ANNOTATION + ".Read"; //$NON-NLS-1$
public static final String PERMISSION_ANNOTATION_WRITE = PERMISSION_ANNOTATION + ".Write"; //$NON-NLS-1$
public static final String RES_SUFFIX = "Res";
public static final String THREAD_SUFFIX = "Thread";
public static final String ATTR_SUGGEST = "suggest";
public static final String ATTR_TO = "to";
public static final String ATTR_FROM = "from";
public static final String ATTR_FROM_INCLUSIVE = "fromInclusive";
public static final String ATTR_TO_INCLUSIVE = "toInclusive";
public static final String ATTR_MULTIPLE = "multiple";
public static final String ATTR_MIN = "min";
public static final String ATTR_MAX = "max";
public static final String ATTR_ALL_OF = "allOf";
public static final String ATTR_ANY_OF = "anyOf";
public static final String ATTR_CONDITIONAL = "conditional";
/**
* Marker ResourceType used to signify that an expression is of type {@code @ColorInt},
* which isn't actually a ResourceType but one we want to specifically compare with.
* We're using {@link ResourceType#PUBLIC} because that one won't appear in the R
* class (and ResourceType is an enum we can't just create new constants for.)
*/
public static final ResourceType COLOR_INT_MARKER_TYPE = ResourceType.PUBLIC;
/**
* Constructs a new {@link SupportAnnotationDetector} check
*/
public SupportAnnotationDetector() {
}
private void checkMethodAnnotation(
@NonNull JavaContext context,
@NonNull ResolvedMethod method,
@NonNull Node node,
@NonNull ResolvedAnnotation annotation) {
String signature = annotation.getSignature();
if (CHECK_RESULT_ANNOTATION.equals(signature)
|| signature.endsWith(".CheckReturnValue")) { // support findbugs annotation too
checkResult(context, node, annotation);
} else if (signature.equals(PERMISSION_ANNOTATION)) {
PermissionRequirement requirement = PermissionRequirement.create(context, annotation);
checkPermission(context, node, method, null, requirement);
} else if (signature.endsWith(THREAD_SUFFIX)
&& signature.startsWith(SUPPORT_ANNOTATIONS_PREFIX)) {
checkThreading(context, node, method, signature);
}
}
private void checkParameterAnnotation(
@NonNull JavaContext context,
@NonNull Node argument,
@NonNull Node call,
@NonNull ResolvedMethod method,
@NonNull ResolvedAnnotation annotation,
@NonNull Iterable<ResolvedAnnotation> allAnnotations) {
String signature = annotation.getSignature();
if (COLOR_INT_ANNOTATION.equals(signature)) {
checkColor(context, argument);
} else if (signature.equals(INT_RANGE_ANNOTATION)) {
checkIntRange(context, annotation, argument, allAnnotations);
} else if (signature.equals(FLOAT_RANGE_ANNOTATION)) {
checkFloatRange(context, annotation, argument);
} else if (signature.equals(SIZE_ANNOTATION)) {
checkSize(context, annotation, argument);
} else if (signature.startsWith(PERMISSION_ANNOTATION)) {
// PERMISSION_ANNOTATION, PERMISSION_ANNOTATION_READ, PERMISSION_ANNOTATION_WRITE
// When specified on a parameter, that indicates that we're dealing with
// a permission requirement on this *method* which depends on the value
// supplied by this parameter
checkParameterPermission(context, signature, call, method, argument);
} else {
// We only run @IntDef, @StringDef and @<Type>Res checks if we're not
// running inside Android Studio / IntelliJ where there are already inspections
// covering the same warnings (using IntelliJ's own data flow analysis); we
// don't want to (a) create redundant warnings or (b) work harder than we
// have to
if (signature.equals(INT_DEF_ANNOTATION)) {
boolean flag = annotation.getValue(TYPE_DEF_FLAG_ATTRIBUTE) == Boolean.TRUE;
checkTypeDefConstant(context, annotation, argument, null, flag, allAnnotations);
} else if (signature.equals(STRING_DEF_ANNOTATION)) {
checkTypeDefConstant(context, annotation, argument, null, false, allAnnotations);
} else if (signature.endsWith(RES_SUFFIX)) {
String typeString = signature.substring(SUPPORT_ANNOTATIONS_PREFIX.length(),
signature.length() - RES_SUFFIX.length()).toLowerCase(Locale.US);
ResourceType type = ResourceType.getEnum(typeString);
if (type != null) {
checkResourceType(context, argument, type);
} else if (typeString.equals("any")) { // @AnyRes
checkResourceType(context, argument, null);
}
}
}
}
private void checkParameterPermission(
@NonNull JavaContext context,
@NonNull String signature,
@NonNull Node call,
@NonNull ResolvedMethod method,
@NonNull Node argument) {
Operation operation = null;
if (signature.equals(PERMISSION_ANNOTATION_READ)) {
operation = READ;
} else if (signature.equals(PERMISSION_ANNOTATION_WRITE)) {
operation = WRITE;
} else {
TypeDescriptor type = context.getType(argument);
if (type == null) {
return;
}
if (type.matchesSignature(CLASS_INTENT)) {
operation = ACTION;
}
}
if (operation == null) {
return;
}
Result result = PermissionFinder.findRequiredPermissions(operation, context, argument);
if (result != null) {
checkPermission(context, call, method, result, result.requirement);
}
}
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);
}
}
private void checkPermission(
@NonNull JavaContext context,
@NonNull Node node,
@Nullable ResolvedMethod method,
@Nullable Result result,
@NonNull PermissionRequirement requirement) {
if (requirement.isConditional()) {
return;
}
PermissionHolder permissions = getPermissions(context);
if (!requirement.isSatisfied(permissions)) {
// See if it looks like we're holding the permission implicitly by @RequirePermission
// annotations in the surrounding context
permissions = addLocalPermissions(context, permissions, node);
if (!requirement.isSatisfied(permissions)) {
Operation operation;
String name;
if (result != null) {
name = result.name;
operation = result.operation;
} else {
assert method != null;
name = method.getContainingClass().getSimpleName() + "." + method.getName();
operation = Operation.CALL;
}
String message = getMissingPermissionMessage(requirement, name, permissions,
operation);
context.report(MISSING_PERMISSION, node, context.getLocation(node), message);
}
} else if (requirement.isRevocable(permissions) &&
context.getMainProject().getTargetSdkVersion().getFeatureLevel() >= 23) {
// Ensure that the caller is handling a security exception
// First check to see if we're inside a try/catch which catches a SecurityException
// (or some wider exception than that). Check for nested try/catches too.
boolean handlesMissingPermission = false;
Node parent = node;
while (true) {
Try tryCatch = getParentOfType(parent, Try.class);
if (tryCatch == null) {
break;
} else {
for (Catch aCatch : tryCatch.astCatches()) {
TypeReference catchType = aCatch.astExceptionDeclaration().
astTypeReference();
if (isSecurityException(context,
catchType)) {
handlesMissingPermission = true;
break;
}
}
parent = tryCatch;
}
}
// If not, check to see if the method itself declares that it throws a
// SecurityException or something wider.
if (!handlesMissingPermission) {
MethodDeclaration declaration = getParentOfType(parent, MethodDeclaration.class);
if (declaration != null) {
for (TypeReference typeReference : declaration.astThrownTypeReferences()) {
if (isSecurityException(context, typeReference)) {
handlesMissingPermission = true;
break;
}
}
}
}
// If not, check to see if the code is deliberately checking to see if the
// given permission is available.
if (!handlesMissingPermission) {
Node methodNode = JavaContext.findSurroundingMethod(node);
if (methodNode != null) {
CheckPermissionVisitor visitor = new CheckPermissionVisitor(node);
methodNode.accept(visitor);
handlesMissingPermission = visitor.checksPermission();
}
}
if (!handlesMissingPermission) {
String message = getUnhandledPermissionMessage();
context.report(MISSING_PERMISSION, node, context.getLocation(node), message);
}
}
}
@NonNull
private static PermissionHolder addLocalPermissions(
@NonNull JavaContext context,
@NonNull PermissionHolder permissions,
@NonNull Node node) {
// Accumulate @RequirePermissions available in the local context
Node methodNode = JavaContext.findSurroundingMethod(node);
if (methodNode == null) {
return permissions;
}
ResolvedNode resolved = context.resolve(methodNode);
if (!(resolved instanceof ResolvedMethod)) {
return permissions;
}
ResolvedMethod method = (ResolvedMethod) resolved;
ResolvedAnnotation annotation = method.getAnnotation(PERMISSION_ANNOTATION);
permissions = mergeAnnotationPermissions(context, permissions, annotation);
annotation = method.getContainingClass().getAnnotation(PERMISSION_ANNOTATION);
permissions = mergeAnnotationPermissions(context, permissions, annotation);
return permissions;
}
@NonNull
private static PermissionHolder mergeAnnotationPermissions(
@NonNull JavaContext context,
@NonNull PermissionHolder permissions,
@Nullable ResolvedAnnotation annotation) {
if (annotation != null) {
PermissionRequirement requirement = PermissionRequirement.create(context, annotation);
permissions = SetPermissionLookup.join(permissions, requirement);
}
return permissions;
}
/** Returns the error message shown when a given call is missing one or more permissions */
public static String getMissingPermissionMessage(@NonNull PermissionRequirement requirement,
@NonNull String callName, @NonNull PermissionHolder permissions,
@NonNull Operation operation) {
return String.format("Missing permissions required %1$s %2$s: %3$s", operation.prefix(),
callName, requirement.describeMissingPermissions(permissions));
}
/** Returns the error message shown when a revocable permission call is not properly handled */
public static String getUnhandledPermissionMessage() {
return "Call requires permission which may be rejected by user: code should explicitly "
+ "check to see if permission is available (with `checkPermission`) or handle "
+ "a potential `SecurityException`";
}
/**
* Visitor which looks through a method, up to a given call (the one requiring a
* permission) and checks whether it's preceeded by a call to checkPermission or
* checkCallingPermission or enforcePermission etc.
* <p>
* Currently it only looks for the presence of this check; it does not perform
* flow analysis to determine whether the check actually affects program flow
* up to the permission call, or whether the check permission is checking for
* permissions sufficient to satisfy the permission requirement of the target call,
* or whether the check return value (== PERMISSION_GRANTED vs != PERMISSION_GRANTED)
* is handled correctly, etc.
*/
private static class CheckPermissionVisitor extends ForwardingAstVisitor {
private boolean mChecksPermission;
private boolean mDone;
private final Node mTarget;
public CheckPermissionVisitor(@NonNull Node target) {
mTarget = target;
}
@Override
public boolean visitNode(Node node) {
return mDone;
}
@Override
public boolean visitMethodInvocation(MethodInvocation node) {
if (node == mTarget) {
mDone = true;
}
String name = node.astName().astValue();
if ((name.startsWith("check") || name.startsWith("enforce"))
&& name.endsWith("Permission")) {
mChecksPermission = true;
mDone = true;
}
return super.visitMethodInvocation(node);
}
public boolean checksPermission() {
return mChecksPermission;
}
}
private static boolean isSecurityException(
@NonNull JavaContext context,
@NonNull TypeReference typeReference) {
TypeDescriptor type = context.getType(typeReference);
return type != null && (type.matchesSignature("java.lang.SecurityException") ||
type.matchesSignature("java.lang.RuntimeException") ||
type.matchesSignature("java.lang.Exception") ||
type.matchesSignature("java.lang.Throwable"));
}
private PermissionHolder mPermissions;
private PermissionHolder getPermissions(
@NonNull JavaContext context) {
if (mPermissions == null) {
Set<String> permissions = Sets.newHashSetWithExpectedSize(30);
Set<String> revocable = Sets.newHashSetWithExpectedSize(4);
LintClient client = context.getClient();
// Gather permissions from all projects that contribute to the
// main project.
Project mainProject = context.getMainProject();
for (File manifest : mainProject.getManifestFiles()) {
addPermissions(client, permissions, revocable, manifest);
}
for (Project library : mainProject.getAllLibraries()) {
for (File manifest : library.getManifestFiles()) {
addPermissions(client, permissions, revocable, manifest);
}
}
AndroidVersion minSdkVersion = mainProject.getMinSdkVersion();
AndroidVersion targetSdkVersion = mainProject.getTargetSdkVersion();
mPermissions = new SetPermissionLookup(permissions, revocable, minSdkVersion,
targetSdkVersion);
}
return mPermissions;
}
private static void addPermissions(@NonNull LintClient client,
@NonNull Set<String> permissions,
@NonNull Set<String> revocable,
@NonNull File manifest) {
Document document = XmlUtils.parseDocumentSilently(client.readFile(manifest), true);
if (document == null) {
return;
}
Element root = document.getDocumentElement();
if (root == null) {
return;
}
NodeList children = root.getChildNodes();
for (int i = 0, n = children.getLength(); i < n; i++) {
org.w3c.dom.Node item = children.item(i);
if (item.getNodeType() != org.w3c.dom.Node.ELEMENT_NODE) {
continue;
}
String nodeName = item.getNodeName();
if (nodeName.equals(TAG_USES_PERMISSION)) {
Element element = (Element)item;
String name = element.getAttributeNS(ANDROID_URI, ATTR_NAME);
if (!name.isEmpty()) {
permissions.add(name);
}
} else if (nodeName.equals(TAG_PERMISSION)) {
Element element = (Element)item;
String protectionLevel = element.getAttributeNS(ANDROID_URI,
ATTR_PROTECTION_LEVEL);
if (VALUE_DANGEROUS.equals(protectionLevel)) {
String name = element.getAttributeNS(ANDROID_URI, ATTR_NAME);
if (!name.isEmpty()) {
revocable.add(name);
}
}
}
}
}
private static void checkResult(@NonNull JavaContext context, @NonNull Node node,
@NonNull ResolvedAnnotation annotation) {
if (node.getParent() instanceof ExpressionStatement) {
String methodName = JavaContext.getMethodName(node);
Object suggested = annotation.getValue(ATTR_SUGGEST);
// Failing to check permissions is a potential security issue (and had an existing
// dedicated issue id before which people may already have configured with a
// custom severity in their LintOptions etc) so continue to use that issue
// (which also has category Security rather than Correctness) for these:
Issue issue = CHECK_RESULT;
if (methodName != null && methodName.startsWith("check")
&& methodName.contains("Permission")) {
issue = CHECK_PERMISSION;
}
String message = String.format("The result of `%1$s` is not used",
methodName);
if (suggested != null) {
// TODO: Resolve suggest attribute (e.g. prefix annotation class if it starts
// with "#" etc?
message = String.format(
"The result of `%1$s` is not used; did you mean to call `%2$s`?",
methodName, suggested.toString());
}
context.report(issue, node, context.getLocation(node), message);
}
}
private static void checkThreading(
@NonNull JavaContext context,
@NonNull Node node,
@NonNull ResolvedMethod method,
@NonNull String annotation) {
String threadContext = getThreadContext(context, node);
if (threadContext != null && !isCompatibleThread(threadContext, annotation)) {
String message = String.format("Method %1$s must be called from the `%2$s` thread, currently inferred thread is `%3$s` thread",
method.getName(), describeThread(annotation), describeThread(threadContext));
context.report(THREAD, node, context.getLocation(node), message);
}
}
@NonNull
public static String describeThread(@NonNull String annotation) {
if (UI_THREAD_ANNOTATION.equals(annotation)) {
return "UI";
}
else if (MAIN_THREAD_ANNOTATION.equals(annotation)) {
return "main";
}
else if (BINDER_THREAD_ANNOTATION.equals(annotation)) {
return "binder";
}
else if (WORKER_THREAD_ANNOTATION.equals(annotation)) {
return "worker";
} else {
return "other";
}
}
/** returns true if the two threads are compatible */
public static boolean isCompatibleThread(@NonNull String thread1, @NonNull String thread2) {
if (thread1.equals(thread2)) {
return true;
}
// Allow @UiThread and @MainThread to be combined
if (thread1.equals(UI_THREAD_ANNOTATION)) {
if (thread2.equals(MAIN_THREAD_ANNOTATION)) {
return true;
}
} else if (thread1.equals(MAIN_THREAD_ANNOTATION)) {
if (thread2.equals(UI_THREAD_ANNOTATION)) {
return true;
}
}
return false;
}
/** Attempts to infer the current thread context at the site of the given method call */
@Nullable
private static String getThreadContext(@NonNull JavaContext context,
@NonNull Node methodCall) {
Node node = findSurroundingMethod(methodCall);
if (node != null) {
ResolvedNode resolved = context.resolve(node);
if (resolved instanceof ResolvedMethod) {
ResolvedMethod method = (ResolvedMethod) resolved;
ResolvedClass cls = method.getContainingClass();
while (method != null) {
for (ResolvedAnnotation annotation : method.getAnnotations()) {
String name = annotation.getSignature();
if (name.startsWith(SUPPORT_ANNOTATIONS_PREFIX)
&& name.endsWith(THREAD_SUFFIX)) {
return name;
}
}
method = method.getSuperMethod();
}
// See if we're extending a class with a known threading context
while (cls != null) {
for (ResolvedAnnotation annotation : cls.getAnnotations()) {
String name = annotation.getSignature();
if (name.startsWith(SUPPORT_ANNOTATIONS_PREFIX)
&& name.endsWith(THREAD_SUFFIX)) {
return name;
}
}
cls = cls.getSuperClass();
}
}
}
// In the future, we could also try to infer the threading context using
// other heuristics. For example, if we're in a method with unknown threading
// context, but we see that the method is called by another method with a known
// threading context, we can infer that that threading context is the context for
// this thread too (assuming the call is direct).
return null;
}
private static boolean isNumber(@NonNull Node argument) {
return argument instanceof IntegralLiteral || argument instanceof UnaryExpression
&& ((UnaryExpression) argument).astOperator() == UnaryOperator.UNARY_MINUS
&& ((UnaryExpression) argument).astOperand() instanceof IntegralLiteral;
}
private static boolean isZero(@NonNull Node argument) {
return argument instanceof IntegralLiteral
&& ((IntegralLiteral) argument).astIntValue() == 0;
}
private static boolean isMinusOne(@NonNull Node argument) {
return argument instanceof UnaryExpression
&& ((UnaryExpression) argument).astOperator() == UnaryOperator.UNARY_MINUS
&& ((UnaryExpression) argument).astOperand() instanceof IntegralLiteral
&& ((IntegralLiteral) ((UnaryExpression) argument).astOperand()).astIntValue()
== 1;
}
private static void checkResourceType(
@NonNull JavaContext context,
@NonNull Node argument,
@Nullable ResourceType expectedType) {
List<ResourceType> actual = getResourceTypes(context, argument);
if (actual == null && (!isNumber(argument) || isZero(argument) || isMinusOne(argument)) ) {
return;
} else if (actual != null && (expectedType == null
|| actual.contains(expectedType)
|| expectedType == DRAWABLE && (actual.contains(COLOR) || actual.contains(MIPMAP)))) {
return;
}
String message;
if (actual != null && actual.size() == 1 && actual.get(0) == COLOR_INT_MARKER_TYPE) {
message = "Expected a color resource id (`R.color.`) but received an RGB integer";
} else if (expectedType == COLOR_INT_MARKER_TYPE) {
message = String.format("Should pass resolved color instead of resource id here: " +
"`getResources().getColor(%1$s)`", argument.toString());
} else if (expectedType != null) {
message = String.format(
"Expected resource of type %1$s", expectedType.getName());
} else {
message = "Expected resource identifier (`R`.type.`name`)";
}
context.report(RESOURCE_TYPE, argument, context.getLocation(argument), message);
}
@Nullable
private static List<ResourceType> getResourceTypes(@NonNull JavaContext context,
@NonNull Node argument) {
if (argument instanceof Select) {
Select node = (Select) argument;
if (node.astOperand() instanceof Select) {
Select select = (Select) node.astOperand();
if (select.astOperand() instanceof Select) { // android.R....
Select innerSelect = (Select) select.astOperand();
if (innerSelect.astIdentifier().astValue().equals(R_CLASS)) {
String typeName = select.astIdentifier().astValue();
ResourceType type = ResourceType.getEnum(typeName);
return type != null ? Collections.singletonList(type) : null;
}
}
if (select.astOperand() instanceof VariableReference) {
VariableReference reference = (VariableReference) select.astOperand();
if (reference.astIdentifier().astValue().equals(R_CLASS)) {
String typeName = select.astIdentifier().astValue();
ResourceType type = ResourceType.getEnum(typeName);
return type != null ? Collections.singletonList(type) : null;
}
}
}
// Arbitrary packages -- android.R.type.name, foo.bar.R.type.name
if (node.astIdentifier().astValue().equals(R_CLASS)) {
Node parent = node.getParent();
if (parent instanceof Select) {
Node grandParent = parent.getParent();
if (grandParent instanceof Select) {
Select select = (Select) grandParent;
Expression typeOperand = select.astOperand();
if (typeOperand instanceof Select) {
Select typeSelect = (Select) typeOperand;
String typeName = typeSelect.astIdentifier().astValue();
ResourceType type = ResourceType.getEnum(typeName);
return type != null ? Collections.singletonList(type) : null;
}
}
}
}
} else if (argument instanceof VariableReference) {
Statement statement = getParentOfType(argument, Statement.class, false);
if (statement != null) {
ListIterator<Node> iterator = statement.getParent().getChildren().listIterator();
while (iterator.hasNext()) {
if (iterator.next() == statement) {
if (iterator.hasPrevious()) { // should always be true
iterator.previous();
}
break;
}
}
String targetName = ((VariableReference)argument).astIdentifier().astValue();
while (iterator.hasPrevious()) {
Node previous = iterator.previous();
if (previous instanceof VariableDeclaration) {
VariableDeclaration declaration = (VariableDeclaration) previous;
VariableDefinition definition = declaration.astDefinition();
for (VariableDefinitionEntry entry : definition
.astVariables()) {
if (entry.astInitializer() != null
&& entry.astName().astValue().equals(targetName)) {
return getResourceTypes(context, entry.astInitializer());
}
}
} else if (previous instanceof ExpressionStatement) {
ExpressionStatement expressionStatement = (ExpressionStatement) previous;
Expression expression = expressionStatement.astExpression();
if (expression instanceof BinaryExpression &&
((BinaryExpression) expression).astOperator()
== BinaryOperator.ASSIGN) {
BinaryExpression binaryExpression = (BinaryExpression) expression;
if (targetName.equals(binaryExpression.astLeft().toString())) {
return getResourceTypes(context, binaryExpression.astRight());
}
}
}
}
}
} else if (argument instanceof MethodInvocation) {
ResolvedNode resolved = context.resolve(argument);
if (resolved != null) {
for (ResolvedAnnotation annotation : resolved.getAnnotations()) {
String signature = annotation.getSignature();
if (signature.equals(COLOR_INT_ANNOTATION)) {
return Collections.singletonList(COLOR_INT_MARKER_TYPE);
}
if (signature.endsWith(RES_SUFFIX)
&& signature.startsWith(SUPPORT_ANNOTATIONS_PREFIX)) {
String typeString = signature.substring(SUPPORT_ANNOTATIONS_PREFIX.length(),
signature.length() - RES_SUFFIX.length()).toLowerCase(Locale.US);
ResourceType type = ResourceType.getEnum(typeString);
if (type != null) {
return Collections.singletonList(type);
} else if (typeString.equals("any")) { // @AnyRes
ResourceType[] types = ResourceType.values();
List<ResourceType> result = Lists.newArrayListWithExpectedSize(
types.length);
for (ResourceType t : types) {
if (t != COLOR_INT_MARKER_TYPE) {
result.add(t);
}
}
return result;
}
}
}
}
}
return null;
}
private static void checkIntRange(
@NonNull JavaContext context,
@NonNull ResolvedAnnotation annotation,
@NonNull Node argument,
@NonNull Iterable<ResolvedAnnotation> allAnnotations) {
String message = getIntRangeError(context, annotation, argument);
if (message != null) {
if (findIntDef(allAnnotations) != null) {
// Don't flag int range errors if there is an int def annotation there too;
// there could be a valid @IntDef constant. (The @IntDef check will
// perform range validation by calling getIntRange.)
return;
}
context.report(RANGE, argument, context.getLocation(argument), message);
}
}
@Nullable
private static String getIntRangeError(
@NonNull JavaContext context,
@NonNull ResolvedAnnotation annotation,
@NonNull Node argument) {
Object object = ConstantEvaluator.evaluate(context, argument);
if (!(object instanceof Number)) {
return null;
}
long value = ((Number)object).longValue();
long from = getLongAttribute(annotation, ATTR_FROM, Long.MIN_VALUE);
long to = getLongAttribute(annotation, ATTR_TO, Long.MAX_VALUE);
return getIntRangeError(value, from, to);
}
/**
* Checks whether a given integer value is in the allowed range, and if so returns
* null; otherwise returns a suitable error message.
*/
private static String getIntRangeError(long value, long from, long to) {
String message = null;
if (value < from || value > to) {
StringBuilder sb = new StringBuilder(20);
if (value < from) {
sb.append("Value must be \u2265 ");
sb.append(Long.toString(from));
} else {
assert value > to;
sb.append("Value must be \u2264 ");
sb.append(Long.toString(to));
}
sb.append(" (was ").append(value).append(')');
message = sb.toString();
}
return message;
}
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);
}
}
/**
* Checks whether a given floating point value is in the allowed range, and if so returns
* null; otherwise returns a suitable error message.
*/
@Nullable
private static String getFloatRangeError(double value, double from, double to,
boolean fromInclusive, boolean toInclusive, @NonNull Node node) {
if (!((fromInclusive && value >= from || !fromInclusive && value > from) &&
(toInclusive && value <= to || !toInclusive && value < to))) {
StringBuilder sb = new StringBuilder(20);
if (from != Double.NEGATIVE_INFINITY) {
if (to != Double.POSITIVE_INFINITY) {
if (fromInclusive && value < from || !fromInclusive && value <= from) {
sb.append("Value must be ");
if (fromInclusive) {
sb.append('\u2265'); // >= sign
} else {
sb.append('>');
}
sb.append(' ');
sb.append(Double.toString(from));
} else {
assert toInclusive && value > to || !toInclusive && value >= to;
sb.append("Value must be ");
if (toInclusive) {
sb.append('\u2264'); // <= sign
} else {
sb.append('<');
}
sb.append(' ');
sb.append(Double.toString(to));
}
} else {
sb.append("Value must be ");
if (fromInclusive) {
sb.append('\u2265'); // >= sign
} else {
sb.append('>');
}
sb.append(' ');
sb.append(Double.toString(from));
}
} else if (to != Double.POSITIVE_INFINITY) {
sb.append("Value must be ");
if (toInclusive) {
sb.append('\u2264'); // <= sign
} else {
sb.append('<');
}
sb.append(' ');
sb.append(Double.toString(to));
}
sb.append(" (was ");
if (node instanceof FloatingPointLiteral || node instanceof IntegralLiteral) {
// Use source text instead to avoid rounding errors involved in conversion, e.g
// Error: Value must be > 2.5 (was 2.490000009536743) [Range]
// printAtLeastExclusive(2.49f); // ERROR
// ~~~~~
String str = node.toString();
if (str.endsWith("f") || str.endsWith("F")) {
str = str.substring(0, str.length() - 1);
}
sb.append(str);
} else {
sb.append(value);
}
sb.append(')');
return sb.toString();
}
return null;
}
private static void checkSize(
@NonNull JavaContext context,
@NonNull ResolvedAnnotation annotation,
@NonNull Node argument) {
int actual;
if (argument instanceof StringLiteral) {
// Check string length
StringLiteral literal = (StringLiteral) argument;
String s = literal.astValue();
actual = s.length();
} else if (argument instanceof ArrayCreation) {
ArrayCreation literal = (ArrayCreation) argument;
ArrayInitializer initializer = literal.astInitializer();
if (initializer == null) {
return;
}
actual = initializer.astExpressions().size();
} else {
// TODO: Collections syntax, e.g. Arrays.asList => param count, emptyList=0, singleton=1, etc
// TODO: Flow analysis
// No flow analysis for this check yet, only checking literals passed in as parameters
return;
}
long exact = getLongAttribute(annotation, ATTR_VALUE, -1);
long min = getLongAttribute(annotation, ATTR_MIN, Long.MIN_VALUE);
long max = getLongAttribute(annotation, ATTR_MAX, Long.MAX_VALUE);
long multiple = getLongAttribute(annotation, ATTR_MULTIPLE, 1);
String unit;
boolean isString = argument instanceof StringLiteral;
if (isString) {
unit = "length";
} else {
unit = "size";
}
String message = getSizeError(actual, exact, min, max, multiple, unit);
if (message != null) {
context.report(RANGE, argument, context.getLocation(argument), message);
}
}
/**
* Checks whether a given size follows the given constraints, and if so returns
* null; otherwise returns a suitable error message.
*/
private static String getSizeError(long actual, long exact, long min, long max, long multiple,
@NonNull String unit) {
String message = null;
if (exact != -1) {
if (exact != actual) {
message = String.format("Expected %1$s %2$d (was %3$d)",
unit, exact, actual);
}
} else if (actual < min || actual > max) {
StringBuilder sb = new StringBuilder(20);
if (actual < min) {
sb.append("Expected ").append(unit).append(" \u2265 ");
sb.append(Long.toString(min));
} else {
assert actual > max;
sb.append("Expected ").append(unit).append(" \u2264 ");
sb.append(Long.toString(max));
}
sb.append(" (was ").append(actual).append(')');
message = sb.toString();
} else if (actual % multiple != 0) {
message = String.format("Expected %1$s to be a multiple of %2$d (was %3$d "
+ "and should be either %4$d or %5$d)",
unit, multiple, actual, (actual / multiple) * multiple,
(actual / multiple + 1) * multiple);
}
return message;
}
@Nullable
private static ResolvedAnnotation findIntRange(
@NonNull Iterable<ResolvedAnnotation> annotations) {
for (ResolvedAnnotation annotation : annotations) {
if (INT_RANGE_ANNOTATION.equals(annotation.getName())) {
return annotation;
}
}
return null;
}
@Nullable
private static ResolvedAnnotation findIntDef(
@NonNull Iterable<ResolvedAnnotation> annotations) {
for (ResolvedAnnotation annotation : annotations) {
if (INT_DEF_ANNOTATION.equals(annotation.getName())) {
return annotation;
}
}
return null;
}
private static void checkTypeDefConstant(
@NonNull JavaContext context,
@NonNull ResolvedAnnotation annotation,
@NonNull Node argument,
@Nullable Node errorNode,
boolean flag,
@NonNull Iterable<ResolvedAnnotation> allAnnotations) {
if (argument instanceof NullLiteral) {
// Accepted for @StringDef
return;
}
if (argument instanceof StringLiteral) {
StringLiteral string = (StringLiteral) argument;
checkTypeDefConstant(context, annotation, argument, errorNode, false, string.astValue(),
allAnnotations);
} else if (argument instanceof IntegralLiteral) {
IntegralLiteral literal = (IntegralLiteral) argument;
int value = literal.astIntValue();
if (flag && value == 0) {
// Accepted for a flag @IntDef
return;
}
ResolvedAnnotation rangeAnnotation = findIntRange(allAnnotations);
if (rangeAnnotation != null) {
// Allow @IntRange on this number
if (getIntRangeError(context, rangeAnnotation, literal) == null) {
return;
}
}
checkTypeDefConstant(context, annotation, argument, errorNode, flag, value,
allAnnotations);
} else if (isMinusOne(argument)) {
// -1 is accepted unconditionally for flags
if (!flag) {
ResolvedAnnotation rangeAnnotation = findIntRange(allAnnotations);
if (rangeAnnotation != null) {
// Allow @IntRange on this number
if (getIntRangeError(context, rangeAnnotation, argument) == null) {
return;
}
}
reportTypeDef(context, annotation, argument, errorNode, allAnnotations);
}
} else if (argument instanceof InlineIfExpression) {
InlineIfExpression expression = (InlineIfExpression) argument;
if (expression.astIfTrue() != null) {
checkTypeDefConstant(context, annotation, expression.astIfTrue(), errorNode, flag,
allAnnotations);
}
if (expression.astIfFalse() != null) {
checkTypeDefConstant(context, annotation, expression.astIfFalse(), errorNode, flag,
allAnnotations);
}
} else if (argument instanceof UnaryExpression) {
UnaryExpression expression = (UnaryExpression) argument;
UnaryOperator operator = expression.astOperator();
if (flag) {
checkTypeDefConstant(context, annotation, expression.astOperand(), errorNode, true,
allAnnotations);
} else if (operator == UnaryOperator.BINARY_NOT) {
context.report(TYPE_DEF, expression, context.getLocation(expression),
"Flag not allowed here");
} else if (operator == UnaryOperator.UNARY_MINUS) {
ResolvedAnnotation rangeAnnotation = findIntRange(allAnnotations);
if (rangeAnnotation != null) {
// Allow @IntRange on this number
if (getIntRangeError(context, rangeAnnotation, argument) == null) {
return;
}
}
reportTypeDef(context, annotation, argument, errorNode, allAnnotations);
}
} else if (argument instanceof BinaryExpression) {
// If it's ?: then check both the if and else clauses
BinaryExpression expression = (BinaryExpression) argument;
if (flag) {
checkTypeDefConstant(context, annotation, expression.astLeft(), errorNode, true,
allAnnotations);
checkTypeDefConstant(context, annotation, expression.astRight(), errorNode, true,
allAnnotations);
} else {
BinaryOperator operator = expression.astOperator();
if (operator == BinaryOperator.BITWISE_AND
|| operator == BinaryOperator.BITWISE_OR
|| operator == BinaryOperator.BITWISE_XOR) {
context.report(TYPE_DEF, expression, context.getLocation(expression),
"Flag not allowed here");
}
}
} else {
ResolvedNode resolved = context.resolve(argument);
if (resolved instanceof ResolvedField) {
checkTypeDefConstant(context, annotation, argument, errorNode, flag, resolved,
allAnnotations);
} else if (argument instanceof VariableReference) {
Statement statement = getParentOfType(argument, Statement.class, false);
if (statement != null) {
ListIterator<Node> iterator = statement.getParent().getChildren().listIterator();
while (iterator.hasNext()) {
if (iterator.next() == statement) {
if (iterator.hasPrevious()) { // should always be true
iterator.previous();
}
break;
}
}
String targetName = ((VariableReference)argument).astIdentifier().astValue();
while (iterator.hasPrevious()) {
Node previous = iterator.previous();
if (previous instanceof VariableDeclaration) {
VariableDeclaration declaration = (VariableDeclaration) previous;
VariableDefinition definition = declaration.astDefinition();
for (VariableDefinitionEntry entry : definition
.astVariables()) {
if (entry.astInitializer() != null
&& entry.astName().astValue().equals(targetName)) {
checkTypeDefConstant(context, annotation,
entry.astInitializer(),
errorNode != null ? errorNode : argument, flag,
allAnnotations);
return;
}
}
} else if (previous instanceof ExpressionStatement) {
ExpressionStatement expressionStatement = (ExpressionStatement) previous;
Expression expression = expressionStatement.astExpression();
if (expression instanceof BinaryExpression &&
((BinaryExpression) expression).astOperator()
== BinaryOperator.ASSIGN) {
BinaryExpression binaryExpression = (BinaryExpression) expression;
if (targetName.equals(binaryExpression.astLeft().toString())) {
checkTypeDefConstant(context, annotation,
binaryExpression.astRight(),
errorNode != null ? errorNode : argument, flag,
allAnnotations);
return;
}
}
}
}
}
}
}
}
private static void checkTypeDefConstant(@NonNull JavaContext context,
@NonNull ResolvedAnnotation annotation, @NonNull Node argument,
@Nullable Node errorNode, boolean flag, Object value,
@NonNull Iterable<ResolvedAnnotation> allAnnotations) {
Object allowed = annotation.getValue();
if (allowed instanceof Object[]) {
Object[] allowedValues = (Object[]) allowed;
for (Object o : allowedValues) {
if (o.equals(value)) {
return;
}
}
reportTypeDef(context, argument, errorNode, flag, allowedValues, allAnnotations);
}
}
private static void reportTypeDef(@NonNull JavaContext context,
@NonNull ResolvedAnnotation annotation, @NonNull Node argument,
@Nullable Node errorNode, @NonNull Iterable<ResolvedAnnotation> allAnnotations) {
Object allowed = annotation.getValue();
if (allowed instanceof Object[]) {
Object[] allowedValues = (Object[]) allowed;
reportTypeDef(context, argument, errorNode, false, allowedValues, allAnnotations);
}
}
private static void reportTypeDef(@NonNull JavaContext context, @NonNull Node node,
@Nullable Node errorNode, boolean flag, @NonNull Object[] allowedValues,
@NonNull Iterable<ResolvedAnnotation> allAnnotations) {
String values = listAllowedValues(allowedValues);
String message;
if (flag) {
message = "Must be one or more of: " + values;
} else {
message = "Must be one of: " + values;
}
ResolvedAnnotation rangeAnnotation = findIntRange(allAnnotations);
if (rangeAnnotation != null) {
// Allow @IntRange on this number
String rangeError = getIntRangeError(context, rangeAnnotation, node);
if (rangeError != null && !rangeError.isEmpty()) {
message += " or " + Character.toLowerCase(rangeError.charAt(0))
+ rangeError.substring(1);
}
}
if (errorNode == null) {
errorNode = node;
}
context.report(TYPE_DEF, errorNode, context.getLocation(errorNode), message);
}
private static String listAllowedValues(@NonNull Object[] allowedValues) {
StringBuilder sb = new StringBuilder();
for (Object allowedValue : allowedValues) {
String s;
if (allowedValue instanceof Integer) {
s = allowedValue.toString();
} else if (allowedValue instanceof ResolvedNode) {
ResolvedNode node = (ResolvedNode) allowedValue;
if (node instanceof ResolvedField) {
ResolvedField field = (ResolvedField) node;
String containingClassName = field.getContainingClassName();
containingClassName = containingClassName.substring(containingClassName.lastIndexOf('.') + 1);
s = containingClassName + "." + field.getName();
} else {
s = node.getSignature();
}
} else {
continue;
}
if (sb.length() > 0) {
sb.append(", ");
}
sb.append(s);
}
return sb.toString();
}
private static double getDoubleAttribute(@NonNull ResolvedAnnotation annotation,
@NonNull String name, double defaultValue) {
Object value = annotation.getValue(name);
if (value instanceof Number) {
return ((Number) value).doubleValue();
}
return defaultValue;
}
private static long getLongAttribute(@NonNull ResolvedAnnotation annotation,
@NonNull String name, long defaultValue) {
Object value = annotation.getValue(name);
if (value instanceof Number) {
return ((Number) value).longValue();
}
return defaultValue;
}
private static boolean getBoolean(@NonNull ResolvedAnnotation annotation,
@NonNull String name, boolean defaultValue) {
Object value = annotation.getValue(name);
if (value instanceof Boolean) {
return ((Boolean) value);
}
return defaultValue;
}
@NonNull
static Iterable<ResolvedAnnotation> filterRelevantAnnotations(
@NonNull Iterable<ResolvedAnnotation> annotations) {
List<ResolvedAnnotation> result = null;
Iterator<ResolvedAnnotation> iterator = annotations.iterator();
int index = 0;
while (iterator.hasNext()) {
ResolvedAnnotation annotation = iterator.next();
index++;
String signature = annotation.getSignature();
if (signature.startsWith("java.")) {
// @Override, @SuppressWarnings etc. Ignore
continue;
}
if (signature.startsWith(SUPPORT_ANNOTATIONS_PREFIX)) {
// Bail on the nullness annotations early since they're the most commonly
// defined ones. They're not analyzed in lint yet.
if (signature.endsWith(".Nullable") || signature.endsWith(".NonNull")) {
continue;
}
// Common case: there's just one annotation; no need to create a list copy
if (!iterator.hasNext() && index == 1) {
return annotations;
}
if (result == null) {
result = new ArrayList<ResolvedAnnotation>(2);
}
result.add(annotation);
}
// Special case @IntDef and @StringDef: These are used on annotations
// themselves. For example, you create a new annotation named @foo.bar.Baz,
// annotate it with @IntDef, and then use @foo.bar.Baz in your signatures.
// Here we want to map from @foo.bar.Baz to the corresponding int def.
// Don't need to compute this if performing @IntDef or @StringDef lookup
ResolvedClass type = annotation.getClassType();
if (type != null) {
Iterator<ResolvedAnnotation> iterator2 = type.getAnnotations().iterator();
while (iterator2.hasNext()) {
ResolvedAnnotation inner = iterator2.next();
if (inner.matches(INT_DEF_ANNOTATION)
|| inner.matches(PERMISSION_ANNOTATION)
|| inner.matches(INT_RANGE_ANNOTATION)
|| inner.matches(STRING_DEF_ANNOTATION)) {
if (!iterator.hasNext() && !iterator2.hasNext() && index == 1) {
return annotations;
}
if (result == null) {
result = new ArrayList<ResolvedAnnotation>(2);
}
result.add(inner);
}
}
}
}
return result != null ? result : Collections.<ResolvedAnnotation>emptyList();
}
// ---- Implements JavaScanner ----
@Override
public
List<Class<? extends Node>> getApplicableNodeTypes() {
//noinspection unchecked
return Arrays.<Class<? extends Node>>asList(
MethodInvocation.class,
ConstructorInvocation.class,
EnumConstant.class);
}
@Nullable
@Override
public AstVisitor createJavaVisitor(@NonNull JavaContext context) {
return new CallVisitor(context);
}
private class CallVisitor extends ForwardingAstVisitor {
private final JavaContext mContext;
public CallVisitor(JavaContext context) {
mContext = context;
}
@Override
public boolean visitMethodInvocation(@NonNull MethodInvocation call) {
ResolvedNode resolved = mContext.resolve(call);
if (resolved instanceof ResolvedMethod) {
ResolvedMethod method = (ResolvedMethod) resolved;
checkCall(call, method);
}
return false;
}
@Override
public boolean visitConstructorInvocation(@NonNull ConstructorInvocation call) {
ResolvedNode resolved = mContext.resolve(call);
if (resolved instanceof ResolvedMethod) {
ResolvedMethod method = (ResolvedMethod) resolved;
checkCall(call, method);
}
return false;
}
@Override
public boolean visitEnumConstant(EnumConstant node) {
ResolvedNode resolved = mContext.resolve(node);
if (resolved instanceof ResolvedMethod) {
ResolvedMethod method = (ResolvedMethod) resolved;
checkCall(node, method);
}
return false;
}
private void checkCall(@NonNull Node call, ResolvedMethod method) {
Iterable<ResolvedAnnotation> annotations = method.getAnnotations();
annotations = filterRelevantAnnotations(annotations);
for (ResolvedAnnotation annotation : annotations) {
checkMethodAnnotation(mContext, method, call, annotation);
}
// Look for annotations on the class as well: these trickle
// down to all the methods in the class
ResolvedClass containingClass = method.getContainingClass();
annotations = containingClass.getAnnotations();
annotations = filterRelevantAnnotations(annotations);
for (ResolvedAnnotation annotation : annotations) {
checkMethodAnnotation(mContext, method, call, annotation);
}
Iterator<Expression> arguments = JavaContext.getParameters(call);
for (int i = 0, n = method.getArgumentCount();
i < n && arguments.hasNext();
i++) {
Expression argument = arguments.next();
annotations = method.getParameterAnnotations(i);
annotations = filterRelevantAnnotations(annotations);
for (ResolvedAnnotation annotation : annotations) {
checkParameterAnnotation(mContext, argument, call, method, annotation,
annotations);
}
}
}
}
}