| /* |
| * Copyright (C) 2018 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 com.android.SdkConstants.CLASS_VIEW |
| import com.android.tools.lint.client.api.UElementHandler |
| import com.android.tools.lint.detector.api.Category |
| 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.Scope |
| import com.android.tools.lint.detector.api.Severity |
| import com.android.tools.lint.detector.api.SourceCodeScanner |
| import com.android.tools.lint.detector.api.isJava |
| import com.intellij.psi.PsiCompiledElement |
| import com.intellij.psi.PsiField |
| import com.intellij.psi.PsiLocalVariable |
| import com.intellij.psi.PsiParameter |
| import org.jetbrains.uast.UBinaryExpression |
| import org.jetbrains.uast.UCallExpression |
| import org.jetbrains.uast.UCallableReferenceExpression |
| import org.jetbrains.uast.UElement |
| import org.jetbrains.uast.UExpression |
| import org.jetbrains.uast.ULambdaExpression |
| import org.jetbrains.uast.ULocalVariable |
| import org.jetbrains.uast.UMethod |
| import org.jetbrains.uast.UReferenceExpression |
| import org.jetbrains.uast.USimpleNameReferenceExpression |
| import org.jetbrains.uast.UastBinaryOperator |
| import org.jetbrains.uast.getContainingUMethod |
| import org.jetbrains.uast.toUElement |
| import org.jetbrains.uast.tryResolve |
| import org.jetbrains.uast.util.isAssignment |
| import org.jetbrains.uast.visitor.AbstractUastVisitor |
| |
| /** |
| * Looks for bugs around implicit SAM conversions |
| */ |
| class SamDetector : Detector(), SourceCodeScanner { |
| companion object Issues { |
| /** Improperly handling implicit SAM instances */ |
| @JvmField |
| val ISSUE = Issue.create( |
| id = "ImplicitSamInstance", |
| briefDescription = "Implicit SAM Instances", |
| explanation = """ |
| Kotlin's support for SAM (single accessor method) interfaces lets you pass \ |
| a lambda to the interface. This will create a new instance on the fly even \ |
| though there is no explicit constructor call. If you pass one of these \ |
| lambdas or method references into a method which (for example) stores or \ |
| compares the object identity, unexpected results may happen. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 6, |
| severity = Severity.WARNING, |
| androidSpecific = null, |
| enabledByDefault = false, |
| implementation = Implementation( |
| SamDetector::class.java, |
| Scope.JAVA_FILE_SCOPE |
| ) |
| ) |
| |
| private const val HANDLER_CLASS = "android.os.Handler" |
| private const val DRAWABLE_CALLBACK_CLASS = "android.graphics.drawable.Drawable.Callback" |
| private const val RUNNABLE_CLASS = "java.lang.Runnable" |
| } |
| |
| override fun getApplicableUastTypes(): List<Class<out UElement>>? = |
| listOf(ULambdaExpression::class.java, UCallableReferenceExpression::class.java) |
| |
| override fun createUastHandler(context: JavaContext): UElementHandler? { |
| val psi = context.uastFile?.sourcePsi ?: return null |
| if (isJava(psi)) { |
| return null |
| } |
| return object : UElementHandler() { |
| override fun visitLambdaExpression(node: ULambdaExpression) { |
| val parent = node.uastParent ?: return |
| if (parent is ULocalVariable) { |
| val psiVar = parent.sourcePsi as? PsiLocalVariable ?: parent.psi ?: return |
| checkCalls(context, node, psiVar) |
| } else if (parent.isAssignment()) { |
| val v = (parent as UBinaryExpression).leftOperand.tryResolve() ?: return |
| val psiVar = v as? PsiLocalVariable ?: return |
| checkCalls(context, node, psiVar) |
| } |
| } |
| |
| override fun visitCallableReferenceExpression(node: UCallableReferenceExpression) { |
| val call = node.uastParent as? UCallExpression ?: return |
| checkLambda(context, node, call, node) |
| } |
| } |
| } |
| |
| private fun checkCalls( |
| context: JavaContext, |
| lambda: ULambdaExpression, |
| variable: PsiLocalVariable |
| ) { |
| val method = lambda.getContainingUMethod() ?: return |
| method.accept(object : AbstractUastVisitor() { |
| override fun visitCallExpression(node: UCallExpression): Boolean { |
| for (argument in node.valueArguments) { |
| if (argument is UReferenceExpression && argument.resolve() == variable) { |
| checkLambda(context, lambda, node, argument) |
| } |
| } |
| return super.visitCallExpression(node) |
| } |
| }) |
| } |
| |
| private fun checkLambda( |
| context: JavaContext, |
| lambda: UExpression, |
| call: UCallExpression, |
| argument: UReferenceExpression |
| ) { |
| val psiMethod = call.resolve() ?: return |
| val evaluator = context.evaluator |
| if (psiMethod is PsiCompiledElement) { |
| // The various Runnable methods in Handler operate on Runnable instances |
| // that are stored. Ditto for View and Drawable.Callback. |
| val containingClass = psiMethod.containingClass |
| if (evaluator.isMemberInClass(psiMethod, HANDLER_CLASS) || |
| evaluator.inheritsFrom(containingClass, CLASS_VIEW, false) || |
| evaluator.inheritsFrom(containingClass, "android.view.ViewTreeObserver", false) || |
| evaluator.inheritsFrom(containingClass, DRAWABLE_CALLBACK_CLASS, false) |
| ) { |
| // idea: only store if temporarily in a variable |
| val map = evaluator.computeArgumentMapping(call, psiMethod) |
| val psiParameter = map[lambda] ?: return |
| val typeString = psiParameter.type.canonicalText |
| if (typeString == RUNNABLE_CLASS) { |
| reportError(context, lambda, typeString, argument) |
| } |
| } |
| return |
| } |
| if (!isJava(psiMethod)) { |
| return |
| } |
| |
| val map = evaluator.computeArgumentMapping(call, psiMethod) |
| val psiParameter = map[argument] ?: return |
| val method = psiMethod.toUElement(UMethod::class.java) ?: return |
| if (storesLambda(method, psiParameter) && |
| !context.driver.isSuppressed(context, ISSUE, method as UElement) |
| ) { |
| val typeString = psiParameter.type.canonicalText |
| reportError(context, lambda, typeString, argument) |
| } |
| } |
| |
| private fun reportError( |
| context: JavaContext, |
| lambda: UExpression, |
| type: String, |
| argument: UReferenceExpression |
| ) { |
| val location = context.getLocation(argument) |
| val simpleType = type.substring(type.lastIndexOf('.') + 1) |
| val range = context.getLocation(lambda) |
| val fix = |
| if (lambda is ULambdaExpression) { |
| fix() |
| .name("Explicitly create $simpleType instance") |
| .replace() |
| .beginning() |
| .with("$simpleType ") |
| .range(range) |
| .build() |
| } else { |
| null |
| } |
| context.report( |
| ISSUE, argument, location, |
| "Implicit new `$simpleType` instance being passed to method which ends up " + |
| "checking instance equality; this can lead to subtle bugs", |
| fix |
| ) |
| } |
| |
| private fun storesLambda(method: UMethod, parameter: PsiParameter): Boolean { |
| var storesLambda = false |
| method.accept(object : AbstractUastVisitor() { |
| override fun visitSimpleNameReferenceExpression(node: USimpleNameReferenceExpression): Boolean { |
| val resolved = node.resolve() |
| if (resolved == parameter) { |
| val parent = node.uastParent |
| if (parent is UCallExpression) { |
| // Decide if we're calling some method which is storing the new instance |
| val methodName = parent.methodName |
| if (methodName != null && |
| (methodName.startsWith("add") || |
| methodName.startsWith("put") || |
| methodName.startsWith("set")) |
| ) { |
| storesLambda = true |
| } |
| } else if (parent is UBinaryExpression) { |
| val kind = parent.operator |
| if (kind == UastBinaryOperator.IDENTITY_EQUALS || |
| kind == UastBinaryOperator.IDENTITY_NOT_EQUALS |
| ) { |
| storesLambda = true |
| } else if (kind == UastBinaryOperator.ASSIGN && parent.rightOperand == node) { |
| val lhs = parent.leftOperand.tryResolve() |
| if (lhs is PsiField) { |
| storesLambda = true |
| } |
| } |
| } |
| // One thing I can try is to let you ONLY invoke methods on these things, |
| // to see what else I can surface |
| } |
| return super.visitSimpleNameReferenceExpression(node) |
| } |
| }) |
| return storesLambda |
| } |
| } |
