| /* |
| * Copyright (C) 2016 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_APPLICATION |
| import com.android.SdkConstants.CLASS_CONTEXT |
| import com.android.SdkConstants.CLASS_FRAGMENT |
| import com.android.SdkConstants.CLASS_VIEW |
| 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.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.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.getMethodName |
| import com.intellij.openapi.util.Ref |
| import com.intellij.psi.PsiClass |
| import com.intellij.psi.PsiClassType |
| import com.intellij.psi.PsiElement |
| import com.intellij.psi.PsiField |
| import com.intellij.psi.PsiKeyword |
| import com.intellij.psi.PsiModifier |
| import com.intellij.psi.PsiModifierList |
| import org.jetbrains.uast.UAnonymousClass |
| import org.jetbrains.uast.UBinaryExpression |
| import org.jetbrains.uast.UCallExpression |
| import org.jetbrains.uast.UClass |
| import org.jetbrains.uast.UElement |
| import org.jetbrains.uast.UField |
| import org.jetbrains.uast.UMethod |
| import org.jetbrains.uast.UObjectLiteralExpression |
| import org.jetbrains.uast.UQualifiedReferenceExpression |
| import org.jetbrains.uast.UResolvable |
| import org.jetbrains.uast.getContainingUClass |
| import org.jetbrains.uast.getParentOfType |
| import org.jetbrains.uast.toUElement |
| import org.jetbrains.uast.util.isAssignment |
| import org.jetbrains.uast.visitor.AbstractUastVisitor |
| import java.util.Locale |
| |
| /** Looks for leaks via static fields */ |
| class LeakDetector : Detector(), SourceCodeScanner { |
| |
| override fun applicableSuperClasses(): List<String>? { |
| return SUPER_CLASSES |
| } |
| |
| /** Warn about inner classes that aren't static: these end up retaining the outer class */ |
| override fun visitClass(context: JavaContext, declaration: UClass) { |
| val containingClass = declaration.getContainingUClass() |
| val isAnonymous = declaration is UAnonymousClass |
| |
| // Only consider static inner classes |
| val evaluator = context.evaluator |
| val isStatic = evaluator.isStatic(declaration) || containingClass == null |
| if (isStatic || isAnonymous) { // containingClass == null: implicitly static |
| // But look for fields that store contexts |
| for (field in declaration.fields) { |
| checkInstanceField(context, field) |
| } |
| |
| if (!isAnonymous) { |
| return |
| } |
| } |
| |
| var superClass: String? = null |
| for (cls in SUPER_CLASSES) { |
| if (evaluator.inheritsFrom(declaration, cls, false)) { |
| superClass = cls |
| break |
| } |
| } |
| superClass ?: return |
| |
| val uastParent = declaration.uastParent |
| if (uastParent != null) { |
| |
| val method = uastParent.getParentOfType<UMethod>( |
| UMethod::class.java, |
| true, |
| UClass::class.java, |
| UObjectLiteralExpression::class.java |
| ) |
| if (method != null && evaluator.isStatic(method)) { |
| return |
| } |
| } |
| |
| val invocation = declaration.getParentOfType<UCallExpression>( |
| UObjectLiteralExpression::class.java, |
| true, |
| UMethod::class.java |
| ) |
| |
| val location: Location |
| location = if (isAnonymous && invocation != null) { |
| context.getCallLocation(invocation, false, false) |
| } else { |
| context.getNameLocation(declaration) |
| } |
| var name: String? |
| if (isAnonymous) { |
| name = "anonymous " + (declaration as UAnonymousClass) |
| .baseClassReference |
| .qualifiedName |
| } else { |
| name = declaration.qualifiedName |
| if (name == null) { |
| name = declaration.name |
| } |
| } |
| |
| val superClassName = superClass.substring(superClass.lastIndexOf('.') + 1) |
| context.report( |
| ISSUE, |
| declaration, |
| location, |
| "This `$superClassName` class should be static or leaks might occur ($name)" |
| ) |
| } |
| |
| override fun getApplicableUastTypes(): List<Class<out UElement>>? { |
| return listOf<Class<out UElement>>(UField::class.java) |
| } |
| |
| override fun createUastHandler(context: JavaContext): UElementHandler? { |
| return FieldChecker(context) |
| } |
| |
| private class FieldChecker(private val context: JavaContext) : UElementHandler() { |
| |
| override fun visitField(node: UField) { |
| val modifierList = node.modifierList |
| if (modifierList == null || !modifierList.hasModifierProperty(PsiModifier.STATIC)) { |
| return |
| } |
| |
| val type = node.type as? PsiClassType ?: return |
| val fqn = type.canonicalText |
| if (fqn.startsWith("java.")) { |
| return |
| } |
| val cls = type.resolve() ?: return |
| if (fqn.startsWith("android.")) { |
| if (isLeakCandidate(cls, context.evaluator) && |
| !isAppContextName(cls, node) && |
| !isInitializedToAppContext(node, cls) |
| ) { |
| val message = |
| "Do not place Android context classes in static fields; " + |
| "this is a memory leak" |
| report(node, modifierList, message) |
| } |
| } else { |
| // User application object -- look to see if that one itself has |
| // static fields? |
| // We only check *one* level of indirection here |
| for ((count, referenced) in cls.allFields.withIndex()) { |
| // Only check a few; avoid getting bogged down on large classes |
| if (count == 20) { |
| break |
| } |
| |
| val innerType = referenced.type as? PsiClassType ?: continue |
| |
| val canonical = innerType.canonicalText |
| if (canonical.startsWith("java.")) { |
| continue |
| } |
| val innerCls = innerType.resolve() ?: continue |
| |
| if (canonical.startsWith("android.")) { |
| if (isLeakCandidate(innerCls, context.evaluator) && |
| !isAppContextName(innerCls, referenced) && |
| !isInitializedToAppContext(context, referenced, innerCls) |
| ) { |
| val message = "Do not place Android context classes in static " + |
| "fields (static reference to `${cls.name}` which has field " + |
| "`${referenced.name}` pointing to `${innerCls.name}`); this " + |
| "is a memory leak" |
| report(node, modifierList, message) |
| break |
| } |
| } |
| } |
| } |
| } |
| |
| private fun isInitializedToAppContext( |
| context: JavaContext, |
| field: PsiField, |
| typeClass: PsiClass |
| ): Boolean { |
| if (!context.evaluator.extendsClass(typeClass, CLASS_CONTEXT, false)) { |
| return false |
| } |
| |
| val uField = field.toUElement(UField::class.java) ?: return true |
| return isInitializedToAppContext(uField, typeClass) |
| } |
| |
| /** |
| * If it's a static field see if it's initialized to an app context in one of the |
| * constructors |
| */ |
| private fun isInitializedToAppContext(field: UField, typeClass: PsiClass): Boolean { |
| val containingClass = field.getContainingUClass() ?: return false |
| |
| // Only check for app context if we're dealing with a Context field -- there's |
| // no chance Fragments, Views etc will be the app context. |
| if (!context.evaluator.extendsClass(typeClass, CLASS_CONTEXT, false)) { |
| return false |
| } |
| |
| for (method in containingClass.uastDeclarations) { |
| if (method !is UMethod || !method.isConstructor) { |
| continue |
| } |
| val methodBody = method.uastBody ?: continue |
| val assignedToAppContext = Ref(false) |
| |
| methodBody.accept( |
| object : AbstractUastVisitor() { |
| override fun visitBinaryExpression(node: UBinaryExpression): Boolean { |
| if (node.isAssignment() && |
| node.leftOperand is UResolvable && |
| field.sourcePsi == (node.leftOperand as UResolvable) |
| .resolve() |
| ) { |
| // Yes, assigning to this field |
| // See if the right hand side looks like an app context |
| var rhs: UElement = node.rightOperand |
| while (rhs is UQualifiedReferenceExpression) { |
| rhs = rhs.selector |
| } |
| if (rhs is UCallExpression) { |
| if ("getApplicationContext" == getMethodName(rhs)) { |
| assignedToAppContext.set(true) |
| } |
| } |
| } |
| return super.visitBinaryExpression(node) |
| } |
| }) |
| |
| if (assignedToAppContext.get()) { |
| return true |
| } |
| } |
| |
| return false |
| } |
| |
| private fun report( |
| field: PsiField, |
| modifierList: PsiModifierList, |
| message: String |
| ) { |
| var locationNode: PsiElement = field |
| // Try to find the static modifier itself |
| if (modifierList.hasExplicitModifier(PsiModifier.STATIC)) { |
| var child: PsiElement? = modifierList.firstChild |
| while (child != null) { |
| if (child is PsiKeyword && PsiKeyword.STATIC == child.text) { |
| locationNode = child |
| break |
| } |
| child = child.nextSibling |
| } |
| } |
| val location = context.getLocation(locationNode) |
| context.report(ISSUE, field, location, message) |
| } |
| } |
| |
| private fun checkInstanceField(context: JavaContext, field: UField) { |
| val type = field.type as? PsiClassType ?: return |
| val fqn = type.canonicalText |
| if (fqn.startsWith("java.")) { |
| return |
| } |
| val cls = type.resolve() ?: return |
| |
| if (isLeakCandidate(cls, context.evaluator)) { |
| context.report( |
| LeakDetector.ISSUE, |
| field, |
| context.getLocation(field), |
| "This field leaks a context object" |
| ) |
| } |
| } |
| |
| companion object { |
| /** Leaking data via static fields */ |
| @JvmField |
| val ISSUE = Issue.create( |
| id = "StaticFieldLeak", |
| briefDescription = "Static Field Leaks", |
| explanation = """ |
| A static field will leak contexts. |
| |
| Non-static inner classes have an implicit reference to their outer class. \ |
| If that outer class is for example a `Fragment` or `Activity`, then this \ |
| reference means that the long-running handler/loader/task will hold a \ |
| reference to the activity which prevents it from getting garbage collected. |
| |
| Similarly, direct field references to activities and fragments from these \ |
| longer running instances can cause leaks. |
| |
| ViewModel classes should never point to Views or non-application Contexts. |
| """, |
| category = Category.PERFORMANCE, |
| androidSpecific = true, |
| priority = 6, |
| severity = Severity.WARNING, |
| implementation = Implementation(LeakDetector::class.java, Scope.JAVA_FILE_SCOPE) |
| ) |
| |
| private val SUPER_CLASSES = listOf( |
| "android.content.Loader", |
| "android.support.v4.content.Loader", |
| "android.os.AsyncTask", |
| "android.arch.lifecycle.ViewModel", |
| "androidx.lifecycle.ViewModel" |
| ) |
| |
| private const val CLASS_LIFECYCLE = "androidx.lifecycle.Lifecycle" |
| private const val CLASS_LIFECYCLE_OLD = "android.arch.lifecycle.Lifecycle" |
| |
| private fun isAppContextName(cls: PsiClass, field: PsiField): Boolean { |
| // Don't flag names like "sAppContext" or "applicationContext". |
| val name = field.name |
| val lower = name.toLowerCase(Locale.US) |
| if (lower.contains("appcontext") || lower.contains("application")) { |
| if (CLASS_CONTEXT == cls.qualifiedName) { |
| return true |
| } |
| } |
| |
| return false |
| } |
| |
| private fun isLeakCandidate(cls: PsiClass, evaluator: JavaEvaluator): Boolean { |
| return (evaluator.extendsClass(cls, CLASS_CONTEXT, false) && |
| !evaluator.extendsClass(cls, CLASS_APPLICATION, false)) || |
| evaluator.extendsClass(cls, CLASS_VIEW, false) || |
| evaluator.extendsClass(cls, CLASS_FRAGMENT, false) || |
| // From https://developer.android.com/topic/libraries/architecture/viewmodel: |
| // Caution: A ViewModel must never reference a view, Lifecycle, or any |
| // class that may hold a reference to the activity context |
| evaluator.extendsClass(cls, CLASS_LIFECYCLE, false) || |
| evaluator.extendsClass(cls, CLASS_LIFECYCLE_OLD, false) |
| } |
| } |
| } |
