/*
 * Copyright (C) 2012 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.ATTR_VALUE;
import static com.android.SdkConstants.FQCN_SUPPRESS_LINT;
import static com.android.SdkConstants.INT_DEF_ANNOTATION;
import static com.android.SdkConstants.LONG_DEF_ANNOTATION;
import static com.android.SdkConstants.STRING_DEF_ANNOTATION;
import static com.android.SdkConstants.SUPPORT_ANNOTATIONS_PREFIX;
import static com.android.SdkConstants.TYPE_DEF_FLAG_ATTRIBUTE;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_DOUBLE;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_FLOAT;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_INT;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_LONG;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_SHORT;
import static com.android.tools.lint.client.api.JavaEvaluatorKt.TYPE_STRING;
import static com.android.tools.lint.detector.api.Lint.getAutoBoxedType;
import static com.android.tools.lint.detector.api.ResourceEvaluator.COLOR_INT_ANNOTATION;
import static com.android.tools.lint.detector.api.ResourceEvaluator.DIMENSION_ANNOTATION;
import static com.android.tools.lint.detector.api.ResourceEvaluator.PX_ANNOTATION;
import static com.android.tools.lint.detector.api.ResourceEvaluator.RES_SUFFIX;
import static com.android.tools.lint.detector.api.UastLintUtils.getAnnotationBooleanValue;
import static com.android.tools.lint.detector.api.UastLintUtils.getAnnotationStringValue;
import static com.android.tools.lint.detector.api.UastLintUtils.getAnnotationStringValues;
import static com.android.tools.lint.detector.api.UastLintUtils.getDoubleAttribute;
import static com.android.tools.lint.detector.api.UastLintUtils.getLongAttribute;

import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.support.AndroidxName;
import com.android.tools.lint.client.api.IssueRegistry;
import com.android.tools.lint.client.api.JavaEvaluator;
import com.android.tools.lint.client.api.UElementHandler;
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.ExternalReferenceExpression;
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.LintFix;
import com.android.tools.lint.detector.api.Location;
import com.android.tools.lint.detector.api.Scope;
import com.android.tools.lint.detector.api.Severity;
import com.android.tools.lint.detector.api.SourceCodeScanner;
import com.android.tools.lint.detector.api.UastLintUtils;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.intellij.openapi.project.Project;
import com.intellij.psi.JavaPsiFacade;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiArrayType;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiClassType;
import com.intellij.psi.PsiCompiledElement;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiField;
import com.intellij.psi.PsiJavaCodeReferenceElement;
import com.intellij.psi.PsiLiteral;
import com.intellij.psi.PsiLocalVariable;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiModifierListOwner;
import com.intellij.psi.PsiReferenceExpression;
import com.intellij.psi.PsiType;
import com.intellij.psi.search.GlobalSearchScope;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import kotlin.collections.CollectionsKt;
import org.jetbrains.uast.UAnnotation;
import org.jetbrains.uast.UCallExpression;
import org.jetbrains.uast.UClass;
import org.jetbrains.uast.UDeclaration;
import org.jetbrains.uast.UDeclarationsExpression;
import org.jetbrains.uast.UElement;
import org.jetbrains.uast.UExpression;
import org.jetbrains.uast.UIdentifier;
import org.jetbrains.uast.UIfExpression;
import org.jetbrains.uast.ULiteralExpression;
import org.jetbrains.uast.ULocalVariable;
import org.jetbrains.uast.UMethod;
import org.jetbrains.uast.UNamedExpression;
import org.jetbrains.uast.UParameter;
import org.jetbrains.uast.UParenthesizedExpression;
import org.jetbrains.uast.UReferenceExpression;
import org.jetbrains.uast.USwitchClauseExpression;
import org.jetbrains.uast.USwitchExpression;
import org.jetbrains.uast.UVariable;
import org.jetbrains.uast.UastFacade;
import org.jetbrains.uast.UastUtils;
import org.jetbrains.uast.java.JavaUAnnotation;
import org.jetbrains.uast.java.JavaUTypeCastExpression;
import org.jetbrains.uast.kotlin.KotlinUSwitchExpression;
import org.jetbrains.uast.util.UastExpressionUtils;
import org.jetbrains.uast.visitor.AbstractUastVisitor;

/** Checks annotations to make sure they are valid */
public class AnnotationDetector extends Detector implements SourceCodeScanner {
    public static final String GMS_HIDE_ANNOTATION = "com.google.android.gms.common.internal.Hide";
    public static final AndroidxName CHECK_RESULT_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "CheckResult");
    public static final AndroidxName INT_RANGE_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "IntRange");
    public static final AndroidxName FLOAT_RANGE_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "FloatRange");
    public static final AndroidxName SIZE_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "Size");
    public static final AndroidxName PERMISSION_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX.oldName(), "RequiresPermission");
    public static final AndroidxName UI_THREAD_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "UiThread");
    public static final AndroidxName MAIN_THREAD_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "MainThread");
    public static final AndroidxName WORKER_THREAD_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "WorkerThread");
    public static final AndroidxName BINDER_THREAD_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "BinderThread");
    public static final AndroidxName ANY_THREAD_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "AnyThread");
    public static final AndroidxName RESTRICT_TO_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "RestrictTo");
    public static final AndroidxName VISIBLE_FOR_TESTING_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "VisibleForTesting");
    public static final AndroidxName PERMISSION_ANNOTATION_READ =
            AndroidxName.of(PERMISSION_ANNOTATION, "Read");
    public static final AndroidxName PERMISSION_ANNOTATION_WRITE =
            AndroidxName.of(PERMISSION_ANNOTATION, "Write");

    // TODO: Add analysis to enforce this annotation:
    public static final AndroidxName HALF_FLOAT_ANNOTATION =
            AndroidxName.of(SUPPORT_ANNOTATIONS_PREFIX, "HalfFloat");

    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";

    public static final String SECURITY_EXCEPTION = "java.lang.SecurityException";

    public static final String FINDBUGS_ANNOTATIONS_CHECK_RETURN_VALUE =
            "edu.umd.cs.findbugs.annotations.CheckReturnValue";
    public static final String JAVAX_ANNOTATION_CHECK_RETURN_VALUE =
            "javax.annotation.CheckReturnValue";
    public static final String ERRORPRONE_CAN_IGNORE_RETURN_VALUE =
            "com.google.errorprone.annotations.CanIgnoreReturnValue";
    public static final String GUAVA_VISIBLE_FOR_TESTING =
            "com.google.common.annotations.VisibleForTesting";

    public static final Implementation IMPLEMENTATION =
            new Implementation(AnnotationDetector.class, Scope.JAVA_FILE_SCOPE);

    /** Placing SuppressLint on a local variable doesn't work for class-file based checks */
    public static final Issue INSIDE_METHOD =
            Issue.create(
                    "LocalSuppress",
                    "@SuppressLint on invalid element",
                    "The `@SuppressAnnotation` is used to suppress Lint warnings in Java files. However, "
                            + "while many lint checks analyzes the Java source code, where they can find "
                            + "annotations on (for example) local variables, some checks are analyzing the "
                            + "`.class` files. And in class files, annotations only appear on classes, fields "
                            + "and methods. Annotations placed on local variables disappear. If you attempt "
                            + "to suppress a lint error for a class-file based lint check, the suppress "
                            + "annotation not work. You must move the annotation out to the surrounding method.",
                    Category.CORRECTNESS,
                    3,
                    Severity.ERROR,
                    IMPLEMENTATION);

    /** Incorrectly using a support annotation */
    @SuppressWarnings("WeakerAccess")
    public static final Issue ANNOTATION_USAGE =
            Issue.create(
                    "SupportAnnotationUsage",
                    "Incorrect support annotation usage",
                    "This lint check makes sure that the support annotations (such as "
                            + "`@IntDef` and `@ColorInt`) are used correctly. For example, it's an "
                            + "error to specify an `@IntRange` where the `from` value is higher than "
                            + "the `to` value.",
                    Category.CORRECTNESS,
                    2,
                    Severity.ERROR,
                    IMPLEMENTATION);

    /** IntDef annotations should be unique */
    public static final Issue UNIQUE =
            Issue.create(
                            "UniqueConstants",
                            "Overlapping Enumeration Constants",
                            "The `@IntDef` annotation allows you to "
                                    + "create a light-weight \"enum\" or type definition. However, it's possible to "
                                    + "accidentally specify the same value for two or more of the values, which can "
                                    + "lead to hard-to-detect bugs. This check looks for this scenario and flags any "
                                    + "repeated constants.\n"
                                    + "\n"
                                    + "In some cases, the repeated constant is intentional (for example, renaming a "
                                    + "constant to a more intuitive name, and leaving the old name in place for "
                                    + "compatibility purposes).  In that case, simply suppress this check by adding a "
                                    + "`@SuppressLint(\"UniqueConstants\")` annotation.",
                            Category.CORRECTNESS,
                            3,
                            Severity.ERROR,
                            IMPLEMENTATION)
                    .setAndroidSpecific(true);

    /** Flags should typically be specified as bit shifts */
    public static final Issue FLAG_STYLE =
            Issue.create(
                    "ShiftFlags",
                    "Dangerous Flag Constant Declaration",
                    "When defining multiple constants for use in flags, the recommended style is "
                            + "to use the form `1 << 2`, `1 << 3`, `1 << 4` and so on to ensure that the "
                            + "constants are unique and non-overlapping.",
                    Category.CORRECTNESS,
                    3,
                    Severity.WARNING,
                    IMPLEMENTATION);

    /** All IntDef constants should be included in switch */
    public static final Issue SWITCH_TYPE_DEF =
            Issue.create(
                            "SwitchIntDef",
                            "Missing @IntDef in Switch",
                            "This check warns if a `switch` statement does not explicitly include all "
                                    + "the values declared by the typedef `@IntDef` declaration.",
                            Category.CORRECTNESS,
                            3,
                            Severity.WARNING,
                            IMPLEMENTATION)
                    .setAndroidSpecific(true);

    /** Constructs a new {@link AnnotationDetector} check */
    public AnnotationDetector() {}

    // ---- implements SourceCodeScanner ----

    /**
     * Set of fields we've already warned about {@link #FLAG_STYLE} for; these can be referenced
     * multiple times, so we should only flag them once
     */
    private Set<PsiElement> mWarnedFlags;

    @Override
    public List<Class<? extends UElement>> getApplicableUastTypes() {
        List<Class<? extends UElement>> types = new ArrayList<>(2);
        types.add(UAnnotation.class);
        types.add(USwitchExpression.class);
        return types;
    }

    @Nullable
    @Override
    public UElementHandler createUastHandler(@NonNull JavaContext context) {
        return new AnnotationChecker(context);
    }

    private class AnnotationChecker extends UElementHandler {
        private final JavaContext mContext;

        public AnnotationChecker(JavaContext context) {
            mContext = context;
        }

        @Override
        public void visitAnnotation(@NonNull UAnnotation annotation) {
            String type = annotation.getQualifiedName();
            if (type == null || type.startsWith("java.lang.")) {
                return;
            }

            if (FQCN_SUPPRESS_LINT.equals(type)) {
                UElement parent = annotation.getUastParent();
                if (parent == null) {
                    return;
                }
                // Only flag local variables and parameters (not classes, fields and methods)
                if (!(parent instanceof UDeclarationsExpression
                        || parent instanceof ULocalVariable
                        || parent instanceof UParameter)) {
                    return;
                }
                List<UNamedExpression> attributes = annotation.getAttributeValues();
                if (attributes.size() == 1) {
                    UNamedExpression attribute = attributes.get(0);
                    UExpression value = attribute.getExpression();
                    if (value instanceof ULiteralExpression) {
                        Object v = ((ULiteralExpression) value).getValue();
                        if (v instanceof String) {
                            String id = (String) v;
                            checkSuppressLint(annotation, id);
                        }
                    } else if (UastExpressionUtils.isArrayInitializer(value)) {
                        for (UExpression ex : ((UCallExpression) value).getValueArguments()) {
                            if (ex instanceof ULiteralExpression) {
                                Object v = ((ULiteralExpression) ex).getValue();
                                if (v instanceof String) {
                                    String id = (String) v;
                                    if (!checkSuppressLint(annotation, id)) {
                                        return;
                                    }
                                }
                            }
                        }
                    }
                }
            } else if (SUPPORT_ANNOTATIONS_PREFIX.isPrefix(type)) {
                if (CHECK_RESULT_ANNOTATION.isEquals(type)) {
                    // Check that the return type of this method is not void!
                    if (annotation.getUastParent() instanceof UMethod) {
                        UMethod method = (UMethod) annotation.getUastParent();
                        if (!method.isConstructor()
                                && PsiType.VOID.equals(method.getReturnType())) {
                            mContext.report(
                                    ANNOTATION_USAGE,
                                    annotation,
                                    mContext.getLocation(annotation),
                                    "@CheckResult should not be specified on `void` methods");
                        }
                    }
                } else if (INT_RANGE_ANNOTATION.isEquals(type)
                        || FLOAT_RANGE_ANNOTATION.isEquals(type)) {
                    // Check that the annotated element's type is int or long.
                    // Also make sure that from <= to.
                    boolean invalid;
                    if (INT_RANGE_ANNOTATION.isEquals(type)) {
                        checkTargetType(annotation, TYPE_INT, TYPE_LONG, true);

                        long from =
                                getLongAttribute(mContext, annotation, ATTR_FROM, Long.MIN_VALUE);
                        long to = getLongAttribute(mContext, annotation, ATTR_TO, Long.MAX_VALUE);
                        invalid = from > to;
                    } else {
                        checkTargetType(annotation, TYPE_FLOAT, TYPE_DOUBLE, true);

                        double from =
                                getDoubleAttribute(
                                        mContext, annotation, ATTR_FROM, Double.NEGATIVE_INFINITY);
                        double to =
                                getDoubleAttribute(
                                        mContext, annotation, ATTR_TO, Double.POSITIVE_INFINITY);
                        invalid = from > to;
                    }
                    if (invalid) {
                        mContext.report(
                                ANNOTATION_USAGE,
                                annotation,
                                mContext.getLocation(annotation),
                                "Invalid range: the `from` attribute must be less than "
                                        + "the `to` attribute");
                    }
                } else if (SIZE_ANNOTATION.isEquals(type)) {
                    // Check that the annotated element's type is an array, or a collection
                    // (or at least not an int or long; if so, suggest IntRange)
                    // Make sure the size and the modulo is not negative.
                    int unset = -42;
                    long exact = getLongAttribute(mContext, annotation, ATTR_VALUE, unset);
                    long min = getLongAttribute(mContext, annotation, ATTR_MIN, Long.MIN_VALUE);
                    long max = getLongAttribute(mContext, annotation, ATTR_MAX, Long.MAX_VALUE);
                    long multiple = getLongAttribute(mContext, annotation, ATTR_MULTIPLE, 1);
                    if (min > max) {
                        mContext.report(
                                ANNOTATION_USAGE,
                                annotation,
                                mContext.getLocation(annotation),
                                "Invalid size range: the `min` attribute must be less than "
                                        + "the `max` attribute");
                    } else if (multiple < 1) {
                        mContext.report(
                                ANNOTATION_USAGE,
                                annotation,
                                mContext.getLocation(annotation),
                                "The size multiple must be at least 1");

                    } else if (exact < 0 && exact != unset || min < 0 && min != Long.MIN_VALUE) {
                        mContext.report(
                                ANNOTATION_USAGE,
                                annotation,
                                mContext.getLocation(annotation),
                                "The size can't be negative");
                    }
                } else if (COLOR_INT_ANNOTATION.isEquals(type)) {
                    // Check that ColorInt applies to the right type
                    checkTargetType(annotation, TYPE_INT, TYPE_LONG, true);
                } else if (DIMENSION_ANNOTATION.isEquals(type) || (PX_ANNOTATION.isEquals(type))) {
                    // Check that @Dimension and @Px applies to the right type
                    checkTargetType(annotation, TYPE_INT, TYPE_LONG, TYPE_FLOAT, TYPE_DOUBLE, true);
                } else if (INT_DEF_ANNOTATION.isEquals(type)
                        || LONG_DEF_ANNOTATION.isEquals(type)) {
                    // Make sure IntDef constants are unique
                    ensureUniqueValues(annotation);
                } else if (PERMISSION_ANNOTATION.isEquals(type)
                        || PERMISSION_ANNOTATION_READ.isEquals(type)
                        || PERMISSION_ANNOTATION_WRITE.isEquals(type)) {
                    // Check that if there are no arguments, this is specified on a parameter,
                    // and conversely, on methods and fields there is a valid argument.
                    if (annotation.getUastParent() instanceof UMethod) {
                        String value = getAnnotationStringValue(annotation, ATTR_VALUE);
                        String[] anyOf = getAnnotationStringValues(annotation, ATTR_ANY_OF);
                        String[] allOf = getAnnotationStringValues(annotation, ATTR_ALL_OF);

                        int set = 0;
                        //noinspection VariableNotUsedInsideIf
                        if (value != null) {
                            set++;
                        }
                        //noinspection VariableNotUsedInsideIf
                        if (allOf != null) {
                            set++;
                        }
                        //noinspection VariableNotUsedInsideIf
                        if (anyOf != null) {
                            set++;
                        }

                        if (set == 0) {
                            mContext.report(
                                    ANNOTATION_USAGE,
                                    annotation,
                                    mContext.getLocation(annotation),
                                    "For methods, permission annotation should specify one "
                                            + "of `value`, `anyOf` or `allOf`");
                        } else if (set > 1) {
                            mContext.report(
                                    ANNOTATION_USAGE,
                                    annotation,
                                    mContext.getLocation(annotation),
                                    "Only specify one of `value`, `anyOf` or `allOf`");
                        }
                    }
                } else if (HALF_FLOAT_ANNOTATION.isEquals(type)) {
                    // Check that half floats are on shorts
                    checkTargetType(annotation, TYPE_SHORT, null, true);
                } else if (type.endsWith(RES_SUFFIX)) {
                    // Check that resource type annotations are on ints
                    checkTargetType(annotation, TYPE_INT, TYPE_LONG, true);
                } else if (RESTRICT_TO_ANNOTATION.isEquals(type)) {
                    UExpression attributeValue = annotation.findDeclaredAttributeValue(ATTR_VALUE);
                    if (attributeValue == null) {
                        attributeValue = annotation.findDeclaredAttributeValue(null);
                    }
                    if (attributeValue == null) {
                        mContext.report(
                                ANNOTATION_USAGE,
                                annotation,
                                mContext.getLocation(annotation),
                                "Restrict to what? Expected at least one `RestrictTo.Scope` arguments.");
                    } else {
                        String values = attributeValue.asSourceString();
                        if (values.contains("SUBCLASSES")
                                && annotation.getUastParent() instanceof UClass) {
                            mContext.report(
                                    ANNOTATION_USAGE,
                                    annotation,
                                    mContext.getLocation(annotation),
                                    "`RestrictTo.Scope.SUBCLASSES` should only be specified on methods and fields");
                        }
                    }
                }
            } else {
                // Look for typedefs (and make sure they're specified on the right type)
                PsiElement resolved = annotation.resolve();
                if (resolved != null) {
                    PsiClass cls = (PsiClass) resolved;
                    if (cls.isAnnotationType() && cls.getModifierList() != null) {
                        for (PsiAnnotation a :
                                mContext.getEvaluator().getAllAnnotations(cls, false)) {
                            String name = a.getQualifiedName();
                            if (INT_DEF_ANNOTATION.isEquals(name)) {
                                checkTargetType(annotation, TYPE_INT, TYPE_LONG, true);
                            } else if (LONG_DEF_ANNOTATION.isEquals(name)) {
                                checkTargetType(annotation, TYPE_LONG, null, true);
                            } else if (STRING_DEF_ANNOTATION.isEquals(type)) {
                                checkTargetType(annotation, TYPE_STRING, null, true);
                            }
                        }
                    }
                }
            }
        }

        private void checkTargetType(
                @NonNull UAnnotation node, @NonNull String type, boolean allowCollection) {
            checkTargetType(node, type, null, null, null, allowCollection);
        }

        private void checkTargetType(
                @NonNull UAnnotation node,
                @NonNull String type1,
                @Nullable String type2,
                boolean allowCollection) {
            checkTargetType(node, type1, type2, null, null, allowCollection);
        }

        private void checkTargetType(
                @NonNull UAnnotation node,
                @NonNull String type1,
                @Nullable String type2,
                @Nullable String type3,
                @Nullable String type4,
                boolean allowCollection) {
            UElement parent = node.getUastParent();
            PsiType type;

            if (parent instanceof UDeclarationsExpression) {
                List<UDeclaration> elements = ((UDeclarationsExpression) parent).getDeclarations();
                if (!elements.isEmpty()) {
                    UDeclaration element = elements.get(0);
                    if (element instanceof ULocalVariable) {
                        type = ((ULocalVariable) element).getType();
                    } else {
                        return;
                    }
                } else {
                    return;
                }
            } else if (parent instanceof UMethod) {
                UMethod method = (UMethod) parent;
                type =
                        method.isConstructor()
                                ? mContext.getEvaluator()
                                        .getClassType(UastUtils.getContainingUClass(method))
                                : method.getReturnType();
            } else if (parent instanceof UVariable) {
                // Field or local variable or parameter
                UVariable variable = (UVariable) parent;
                if (variable.getTypeReference() == null) {
                    // Uh oh.
                    // https://youtrack.jetbrains.com/issue/KT-20172
                    return;
                }
                type = variable.getType();
            } else {
                return;
            }
            if (type == null) {
                return;
            }

            if (allowCollection) {
                if (type instanceof PsiArrayType) {
                    // For example, int[]
                    type = type.getDeepComponentType();
                } else if (type instanceof PsiClassType) {
                    // For example, List<Integer>
                    PsiClassType classType = (PsiClassType) type;
                    if (classType.getParameters().length == 1) {
                        PsiClass resolved = classType.resolve();
                        if (resolved != null
                                && mContext.getEvaluator()
                                        .implementsInterface(
                                                resolved, "java.util.Collection", false)) {
                            type = classType.getParameters()[0];
                        }
                    }
                }
            }

            if (!type.isValid()) {
                return;
            }

            String typeName = type.getCanonicalText();
            if (typeName.equals("error.NonExistentClass")) {
                // Type not found. Not awesome.
                // https://youtrack.jetbrains.com/issue/KT-20172
                return;
            }

            if (!(typeName.equals(type1)
                    || typeName.equals(type2)
                    || typeName.equals(type3)
                    || typeName.equals(type4))) {
                // Autoboxing? You can put @DrawableRes on a java.lang.Integer for example
                if (typeName.equals(getAutoBoxedType(type1))
                        || type2 != null && typeName.equals(getAutoBoxedType(type2))
                        || type3 != null && typeName.equals(getAutoBoxedType(type3))
                        || type4 != null && typeName.equals(getAutoBoxedType(type4))) {
                    return;
                }

                String expectedTypes;
                if (type4 != null) {
                    expectedTypes = type1 + ", " + type2 + ", " + type3 + ", or " + type4;
                } else if (type3 != null) {
                    expectedTypes = type1 + ", " + type2 + ", or " + type3;
                } else if (type2 != null) {
                    expectedTypes = type1 + " or " + type2;
                } else {
                    expectedTypes = type1;
                }
                if (typeName.equals(TYPE_STRING)) {
                    typeName = "String";
                }
                String message =
                        String.format(
                                "This annotation does not apply for type %1$s; expected %2$s",
                                typeName, expectedTypes);
                Location location = mContext.getLocation(node);
                mContext.report(ANNOTATION_USAGE, node, location, message);
            }
        }

        @Override
        public void visitSwitchExpression(@NonNull USwitchExpression switchExpression) {
            UExpression condition = switchExpression.getExpression();
            if (condition != null && PsiType.INT.equals(condition.getExpressionType())) {
                UAnnotation annotation = findIntDefAnnotation(condition);
                if (annotation != null) {
                    UExpression value = annotation.findAttributeValue(ATTR_VALUE);
                    if (value == null) {
                        value = annotation.findAttributeValue(null);
                    }

                    if (value != null && UastExpressionUtils.isArrayInitializer(value)) {
                        List<UExpression> allowedValues =
                                ((UCallExpression) value).getValueArguments();
                        switchExpression.accept(new SwitchChecker(switchExpression, allowedValues));
                    }
                }
            }
        }

        /**
         * Searches for the corresponding @IntDef annotation definition associated with a given node
         */
        @Nullable
        private UAnnotation findIntDefAnnotation(@NonNull UExpression expression) {
            if (expression instanceof UReferenceExpression) {
                PsiElement resolved = ((UReferenceExpression) expression).resolve();

                if (resolved instanceof PsiModifierListOwner) {
                    PsiAnnotation[] annotations =
                            mContext.getEvaluator()
                                    .getAllAnnotations((PsiModifierListOwner) resolved, true);
                    PsiAnnotation[] relevantAnnotations =
                            filterRelevantAnnotations(mContext.getEvaluator(), annotations);
                    UAnnotation annotation =
                            TypedefDetector.Companion.findIntDef(
                                    JavaUAnnotation.wrap(relevantAnnotations));
                    if (annotation != null) {
                        return annotation;
                    }
                }

                if (resolved instanceof PsiLocalVariable) {
                    PsiLocalVariable variable = (PsiLocalVariable) resolved;
                    UExpression lastAssignment =
                            UastLintUtils.findLastAssignment(variable, expression);

                    if (lastAssignment != null) {
                        return findIntDefAnnotation(lastAssignment);
                    }
                }
            } else if (expression instanceof UCallExpression) {
                PsiMethod method = ((UCallExpression) expression).resolve();
                if (method != null) {
                    PsiAnnotation[] annotations =
                            mContext.getEvaluator().getAllAnnotations(method, true);
                    PsiAnnotation[] relevantAnnotations =
                            filterRelevantAnnotations(mContext.getEvaluator(), annotations);
                    List<UAnnotation> uAnnotations = JavaUAnnotation.wrap(relevantAnnotations);
                    UAnnotation annotation = TypedefDetector.Companion.findIntDef(uAnnotations);
                    if (annotation != null) {
                        return annotation;
                    }
                }
            } else if (expression instanceof UIfExpression) {
                UIfExpression ifExpression = (UIfExpression) expression;
                if (ifExpression.getThenExpression() != null) {
                    UAnnotation result = findIntDefAnnotation(ifExpression.getThenExpression());
                    if (result != null) {
                        return result;
                    }
                }
                if (ifExpression.getElseExpression() != null) {
                    UAnnotation result = findIntDefAnnotation(ifExpression.getElseExpression());
                    if (result != null) {
                        return result;
                    }
                }
            } else if (expression instanceof JavaUTypeCastExpression) {
                return findIntDefAnnotation(((JavaUTypeCastExpression) expression).getOperand());

            } else if (expression instanceof UParenthesizedExpression) {
                return findIntDefAnnotation(
                        ((UParenthesizedExpression) expression).getExpression());
            }

            return null;
        }

        @Nullable
        private Integer getConstantValue(@NonNull PsiField intDefConstantRef) {
            Object constant = intDefConstantRef.computeConstantValue();
            if (constant instanceof Number) {
                return ((Number) constant).intValue();
            }

            return null;
        }

        private void ensureUniqueValues(@NonNull UAnnotation node) {
            UExpression value = node.findDeclaredAttributeValue(ATTR_VALUE);
            if (value == null) {
                value = node.findDeclaredAttributeValue(null);
            }
            if (value == null) {
                return;
            }

            if (!(UastExpressionUtils.isArrayInitializer(value))) {
                return;
            }

            List<UExpression> initializers = ((UCallExpression) value).getValueArguments();
            Map<Number, Integer> valueToIndex =
                    Maps.newHashMapWithExpectedSize(initializers.size());

            boolean flag = getAnnotationBooleanValue(node, TYPE_DEF_FLAG_ATTRIBUTE) == Boolean.TRUE;
            if (flag) {
                ensureUsingFlagStyle(initializers);
            }

            ConstantEvaluator constantEvaluator = new ConstantEvaluator();
            for (int index = 0; index < initializers.size(); index++) {
                UExpression expression = initializers.get(index);
                Object o = constantEvaluator.evaluate(expression);
                if (o instanceof Number) {
                    Number number = (Number) o;
                    if (valueToIndex.containsKey(number)) {
                        @SuppressWarnings("UnnecessaryLocalVariable")
                        Number repeatedValue = number;

                        Location location;
                        String message;
                        int prevIndex = valueToIndex.get(number);
                        UExpression prevConstant = initializers.get(prevIndex);
                        message =
                                String.format(
                                        "Constants `%1$s` and `%2$s` specify the same exact "
                                                + "value (%3$s); this is usually a cut & paste or "
                                                + "merge error",
                                        expression.asSourceString(),
                                        prevConstant.asSourceString(),
                                        repeatedValue.toString());
                        location = mContext.getLocation(expression);
                        Location secondary = mContext.getLocation(prevConstant);
                        secondary.setMessage("Previous same value");
                        location.setSecondary(secondary);
                        UElement scope = getAnnotationScope(node);
                        mContext.report(UNIQUE, scope, location, message);
                        break;
                    }
                    valueToIndex.put(number, index);
                }
            }
        }

        private void ensureUsingFlagStyle(@NonNull List<UExpression> constants) {
            if (constants.size() < 3) {
                return;
            }

            for (UExpression constant : constants) {
                if (constant instanceof UReferenceExpression) {
                    PsiElement resolved = ((UReferenceExpression) constant).resolve();
                    // Don't try to check complied code.
                    if (!(resolved instanceof PsiCompiledElement) && resolved instanceof PsiField) {
                        UExpression initializer =
                                UastFacade.INSTANCE.getInitializerBody((PsiField) resolved);
                        if (initializer instanceof ULiteralExpression) {
                            ULiteralExpression literal = (ULiteralExpression) initializer;
                            Object o = literal.getValue();
                            if (!(o instanceof Number)) {
                                continue;
                            }
                            long value = ((Number) o).longValue();
                            // Allow -1, 0 and 1. You can write 1 as "1 << 0" but IntelliJ for
                            // example warns that that's a redundant shift.
                            if (Math.abs(value) <= 1) {
                                continue;
                            }
                            // Only warn if we're setting a specific bit
                            if (Long.bitCount(value) != 1) {
                                continue;
                            }
                            int shift = Long.numberOfTrailingZeros(value);
                            if (mWarnedFlags == null) {
                                mWarnedFlags = Sets.newHashSet();
                            }
                            if (!mWarnedFlags.add(resolved)) {
                                return;
                            }
                            String message =
                                    String.format(
                                            Locale.US,
                                            "Consider declaring this constant using 1 << %1$d instead",
                                            shift);
                            String replace =
                                    String.format(
                                            Locale.ROOT,
                                            "1%s << %d",
                                            o instanceof Long ? "L" : "",
                                            shift);
                            LintFix fix =
                                    fix().replace()
                                            .sharedName("Change declaration to <<")
                                            .with(replace)
                                            .autoFix()
                                            .build();
                            Location location = mContext.getLocation(initializer);
                            mContext.report(FLAG_STYLE, initializer, location, message, fix);
                        }
                    }
                }
            }
        }

        private boolean checkSuppressLint(@NonNull UAnnotation node, @NonNull String id) {
            IssueRegistry registry = mContext.getDriver().getRegistry();
            Issue issue = registry.getIssue(id);
            // Special-case the ApiDetector issue, since it does both source file analysis
            // only on field references, and class file analysis on the rest, so we allow
            // annotations outside of methods only on fields
            if (issue != null && !issue.getImplementation().getScope().contains(Scope.JAVA_FILE)
                    || issue == ApiDetector.UNSUPPORTED) {
                // This issue doesn't have AST access: annotations are not
                // available for local variables or parameters
                UElement scope = getAnnotationScope(node);
                mContext.report(
                        INSIDE_METHOD,
                        scope,
                        mContext.getLocation(node),
                        String.format(
                                "The `@SuppressLint` annotation cannot be used on a local "
                                        + "variable with the lint check '%1$s': move out to the "
                                        + "surrounding method",
                                id));
                return false;
            }

            return true;
        }

        private class SwitchChecker extends AbstractUastVisitor {

            private final USwitchExpression mSwitchExpression;
            private final List<UExpression> mAllowedValues;
            private final List<Object> mFields;
            private final List<Integer> mSeenValues;

            private boolean mReported = false;

            private SwitchChecker(
                    USwitchExpression switchExpression, List<UExpression> allowedValues) {
                mSwitchExpression = switchExpression;
                mAllowedValues = allowedValues;

                mFields = Lists.newArrayListWithCapacity(allowedValues.size());
                for (UExpression allowedValue : allowedValues) {
                    if (allowedValue instanceof ExternalReferenceExpression) {
                        ExternalReferenceExpression externalRef =
                                (ExternalReferenceExpression) allowedValue;

                        PsiElement resolved = UastLintUtils.resolve(externalRef, switchExpression);

                        if (resolved instanceof PsiField) {
                            mFields.add(resolved);
                        }
                    } else if (allowedValue instanceof UReferenceExpression) {
                        PsiElement resolved = ((UReferenceExpression) allowedValue).resolve();
                        if (resolved != null) {
                            mFields.add(resolved);
                        }
                    } else if (allowedValue instanceof ULiteralExpression) {
                        mFields.add(allowedValue);
                    }
                }

                mSeenValues = Lists.newArrayListWithCapacity(allowedValues.size());
            }

            @Override
            public boolean visitSwitchClauseExpression(USwitchClauseExpression node) {
                if (mReported) {
                    return true;
                }

                if (mAllowedValues == null) {
                    return true;
                }

                List<UExpression> caseValues = node.getCaseValues();
                if (caseValues.isEmpty()) {
                    // We had an else clause: don't report any as missing
                    mFields.clear();
                    return true;
                }

                for (UExpression caseValue : caseValues) {
                    if (caseValue instanceof ULiteralExpression) {
                        // Report warnings if you specify hardcoded constants.
                        // It's the wrong thing to do.
                        List<String> list = computeFieldNames(mSwitchExpression, mAllowedValues);
                        // Keep error message in sync with {@link #getMissingCases}
                        String message =
                                "Don't use a constant here; expected one of: "
                                        + displayConstants(list);
                        mContext.report(
                                SWITCH_TYPE_DEF,
                                caseValue,
                                mContext.getLocation(caseValue),
                                message);
                        // Don't look for other missing typedef constants since you might
                        // have aliased with value
                        mReported = true;
                    } else if (caseValue
                            instanceof
                            UReferenceExpression) { // default case can have null expression
                        PsiElement resolved = ((UReferenceExpression) caseValue).resolve();
                        if (resolved == null) {
                            // If there are compilation issues (e.g. user is editing code) we
                            // can't be certain, so don't flag anything.
                            return true;
                        }
                        if (resolved instanceof PsiField) {
                            // We can't just do
                            //    fields.remove(resolved);
                            // since the fields list contains instances of potentially
                            // different types with different hash codes (due to the
                            // external annotations, which are not of the same type as
                            // for example the ECJ based ones.
                            //
                            // The equals method on external field class deliberately handles
                            // this (but it can't make its hash code match what
                            // the ECJ fields do, which is tied to the ECJ binding hash code.)
                            // So instead, manually check for equals. These lists tend to
                            // be very short anyway.
                            PsiField resolvedField = (PsiField) resolved;
                            boolean found = removeFieldFromList(mFields, resolvedField);
                            if (!found) {
                                // Look for local alias
                                UExpression initializer =
                                        UastFacade.INSTANCE.getInitializerBody(
                                                ((PsiField) resolved));
                                if (initializer instanceof UReferenceExpression) {
                                    resolved = ((UReferenceExpression) initializer).resolve();
                                    if (resolved instanceof PsiField) {
                                        found = removeFieldFromList(mFields, (PsiField) resolved);
                                    }
                                }
                            }

                            if (found) {
                                Integer cv = getConstantValue((PsiField) resolved);
                                if (cv != null) {
                                    mSeenValues.add(cv);
                                }
                            } else {
                                List<String> list =
                                        computeFieldNames(mSwitchExpression, mAllowedValues);
                                // Keep error message in sync with {@link #getMissingCases}
                                String message =
                                        "Unexpected constant; expected one of: "
                                                + displayConstants(list);
                                LintFix fix = fix().data(list);
                                Location location = mContext.getNameLocation(caseValue);
                                mContext.report(SWITCH_TYPE_DEF, caseValue, location, message, fix);
                            }
                        }
                    }
                }
                return true;
            }

            @Override
            public void afterVisitSwitchExpression(USwitchExpression node) {
                reportMissingSwitchCases();
                super.afterVisitSwitchExpression(node);
            }

            private void reportMissingSwitchCases() {
                if (mReported) {
                    return;
                }

                if (mAllowedValues == null) {
                    return;
                }

                // Any missing switch constants? Before we flag them, look to see if any
                // of them have the same values: those can be omitted
                if (!mFields.isEmpty()) {
                    ListIterator<Object> iterator = mFields.listIterator();
                    while (iterator.hasNext()) {
                        Object next = iterator.next();
                        if (next instanceof PsiField) {
                            Integer cv = getConstantValue((PsiField) next);
                            if (mSeenValues.contains(cv)) {
                                iterator.remove();
                            }
                        }
                    }
                }

                if (!mFields.isEmpty()) {
                    List<String> list = computeFieldNames(mSwitchExpression, mFields);
                    // Keep error message in sync with {@link #getMissingCases}
                    LintFix fix = fix().data(list);
                    UIdentifier identifier = mSwitchExpression.getSwitchIdentifier();
                    Location location = mContext.getLocation(identifier);
                    // Workaround Kotlin UAST passing <error> instead of PsiKeyword as in Java
                    if (mSwitchExpression instanceof KotlinUSwitchExpression
                            && !"when".equals(identifier.getName())) {
                        PsiElement sourcePsi = mSwitchExpression.getSourcePsi();
                        if (sourcePsi != null) {
                            PsiElement keyword = sourcePsi.getFirstChild();
                            if (keyword != null) {
                                location = mContext.getLocation(keyword);
                            }
                        }
                    }
                    String message =
                            "Switch statement on an `int` with known associated constant "
                                    + "missing case "
                                    + displayConstants(list);
                    mContext.report(SWITCH_TYPE_DEF, mSwitchExpression, location, message, fix);
                }
            }
        }
    }

    @NonNull
    private static String displayConstants(List<String> list) {
        return CollectionsKt.joinToString(
                list,
                ", ", // separator
                "", // prefix
                "", // postfix
                -1, // limited
                "", // truncated
                s -> {
                    int index = s.lastIndexOf('.');
                    if (index != -1) {
                        int classIndex = s.lastIndexOf('.', index - 1);
                        if (classIndex != -1) {
                            return "`" + s.substring(classIndex + 1) + "`";
                        }
                    }
                    return "`" + s + "`";
                });
    }

    private static List<String> computeFieldNames(
            @NonNull USwitchExpression node, Iterable<?> allowedValues) {

        List<String> list = Lists.newArrayList();
        for (Object o : allowedValues) {
            if (o instanceof ExternalReferenceExpression) {
                ExternalReferenceExpression externalRef = (ExternalReferenceExpression) o;
                PsiElement resolved = UastLintUtils.resolve(externalRef, node);
                if (resolved != null) {
                    o = resolved;
                }
            } else if (o instanceof PsiReferenceExpression) {
                PsiReferenceExpression ref = (PsiReferenceExpression) o;
                PsiElement resolved = ref.resolve();
                if (resolved != null) {
                    o = resolved;
                } else {
                    String referenceName = ref.getReferenceName();
                    if (referenceName != null) {
                        list.add(referenceName);
                    }
                    continue;
                }
            } else if (o instanceof PsiLiteral) {
                list.add((String) ((PsiLiteral) o).getValue());
                continue;
            } else if (o instanceof UReferenceExpression) {
                UReferenceExpression ref = (UReferenceExpression) o;
                PsiElement resolved = ref.resolve();
                if (resolved == null) {
                    String resolvedName = ref.getResolvedName();
                    if (resolvedName != null) {
                        list.add(resolvedName);
                    }
                    continue;
                }
                o = resolved;
            }

            if (o instanceof PsiField) {
                PsiField field = (PsiField) o;
                // Only include class name if necessary
                String name = field.getName();
                UClass clz = UastUtils.getParentOfType(node, UClass.class, true);
                if (clz != null) {
                    PsiClass containingClass = field.getContainingClass();
                    if (containingClass != null && !containingClass.isEquivalentTo(clz.getPsi())) {
                        name = containingClass.getQualifiedName() + '.' + field.getName();
                    }
                }
                list.add(name);
            }
        }
        Collections.sort(list);
        return list;
    }

    /**
     * Returns the node to use as the scope for the given annotation node. You can't annotate an
     * annotation itself (with {@code @SuppressLint}), but you should be able to place an annotation
     * next to it, as a sibling, to only suppress the error on this annotated element, not the whole
     * surrounding class.
     */
    @NonNull
    private static UElement getAnnotationScope(@NonNull UAnnotation node) {
        UElement scope = UastUtils.getParentOfType(node, UAnnotation.class, true);
        if (scope == null) {
            scope = node;
        }
        return scope;
    }

    private static boolean removeFieldFromList(
            @NonNull List<Object> fields, @NonNull PsiField resolvedField) {
        for (Object field : fields) {
            // We can't just call .equals here because the annotation
            // we are comparing against may be either a PsiFieldImpl
            // (for a local annotation) or a ClsFieldImpl (for an annotation
            // read from storage) or maybe even other PSI internal classes.
            // So compare by name and class instead.

            if (!(field instanceof PsiField)) {
                continue;
            }
            PsiField candidateField = (PsiField) field;
            if (candidateField.isEquivalentTo(resolvedField)) {
                return true;
            }
        }

        return false;
    }

    // Like JavaEvaluator#filterRelevantAnnotations, but hardcoded for the IntRange and
    // IntDef annotations since this check isn't a generalized annotation checker like the
    // others.
    @NonNull
    static PsiAnnotation[] filterRelevantAnnotations(
            @NonNull JavaEvaluator evaluator, @NonNull PsiAnnotation[] annotations) {
        List<PsiAnnotation> result = null;
        int length = annotations.length;
        if (length == 0) {
            return annotations;
        }
        for (PsiAnnotation annotation : annotations) {
            String signature = annotation.getQualifiedName();
            if (signature == null || signature.startsWith("java.")) {
                // @Override, @SuppressWarnings etc. Ignore
                continue;
            }

            if (SUPPORT_ANNOTATIONS_PREFIX.isPrefix(signature)
                    || signature.equals(GMS_HIDE_ANNOTATION)) {
                // 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 (length == 1) {
                    return annotations;
                }
                if (result == null) {
                    result = new ArrayList<>(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
            PsiClass cls = null;
            PsiJavaCodeReferenceElement ref = annotation.getNameReferenceElement();
            if (ref != null) {
                PsiElement resolved = ref.resolve();
                if (resolved instanceof PsiClass) {
                    cls = (PsiClass) resolved;
                }
            } else {
                Project project = annotation.getProject();
                GlobalSearchScope scope = GlobalSearchScope.projectScope(project);
                cls = JavaPsiFacade.getInstance(project).findClass(signature, scope);
            }
            if (cls == null || !cls.isAnnotationType()) {
                continue;
            }
            PsiAnnotation[] innerAnnotations = evaluator.getAllAnnotations(cls, false);
            for (int j = 0; j < innerAnnotations.length; j++) {
                PsiAnnotation inner = innerAnnotations[j];
                String a = inner.getQualifiedName();
                if (a == null || a.startsWith("java.")) {
                    // @Override, @SuppressWarnings etc. Ignore
                    continue;
                }
                if (INT_DEF_ANNOTATION.isEquals(a)
                        || LONG_DEF_ANNOTATION.isEquals(a)
                        || PERMISSION_ANNOTATION.isEquals(a)
                        || INT_RANGE_ANNOTATION.isEquals(a)
                        || STRING_DEF_ANNOTATION.isEquals(a)) {
                    if (length == 1 && j == innerAnnotations.length - 1 && result == null) {
                        return innerAnnotations;
                    }
                    if (result == null) {
                        result = new ArrayList<>(2);
                    }
                    result.add(inner);
                }
            }
        }

        return result != null
                ? result.toArray(PsiAnnotation.EMPTY_ARRAY)
                : PsiAnnotation.EMPTY_ARRAY;
    }
}