| /* |
| * Copyright (C) 2017 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.helpers |
| |
| import com.android.builder.model.Dependencies |
| import com.android.tools.lint.client.api.JavaEvaluator |
| import com.android.tools.lint.detector.api.Project |
| import com.android.tools.lint.detector.api.computeKotlinArgumentMapping |
| import com.android.tools.lint.detector.api.isKotlin |
| import com.google.common.collect.Sets |
| import com.intellij.codeInsight.AnnotationUtil |
| import com.intellij.psi.JavaDirectoryService |
| import com.intellij.psi.JavaPsiFacade |
| import com.intellij.psi.PsiAnnotation |
| import com.intellij.psi.PsiClass |
| import com.intellij.psi.PsiClassType |
| import com.intellij.psi.PsiCompiledFile |
| import com.intellij.psi.PsiElement |
| import com.intellij.psi.PsiFile |
| import com.intellij.psi.PsiJavaFile |
| import com.intellij.psi.PsiMethod |
| import com.intellij.psi.PsiModifierList |
| import com.intellij.psi.PsiModifierListOwner |
| import com.intellij.psi.PsiPackage |
| import com.intellij.psi.PsiParameter |
| import com.intellij.psi.PsiType |
| import com.intellij.psi.impl.file.PsiPackageImpl |
| import com.intellij.psi.impl.source.tree.java.PsiCompositeModifierList |
| import com.intellij.psi.search.GlobalSearchScope |
| import com.intellij.psi.util.InheritanceUtil |
| import com.intellij.psi.util.MethodSignatureUtil |
| import com.intellij.psi.util.TypeConversionUtil |
| import com.intellij.util.io.URLUtil |
| import org.jetbrains.uast.UAnnotated |
| import org.jetbrains.uast.UAnnotation |
| import org.jetbrains.uast.UCallExpression |
| import org.jetbrains.uast.UDeclaration |
| import org.jetbrains.uast.UElement |
| import org.jetbrains.uast.UExpression |
| import org.jetbrains.uast.getContainingUFile |
| import org.jetbrains.uast.java.JavaUAnnotation |
| |
| open class DefaultJavaEvaluator( |
| private val myProject: com.intellij.openapi.project.Project?, |
| private val myLintProject: Project? |
| ) : JavaEvaluator() { |
| // cache of package name to package-info.class. |
| private val packageInfoCache = mutableMapOf<String, PsiPackage>() |
| |
| override val dependencies: Dependencies? |
| get() { |
| if (myLintProject != null && myLintProject.isAndroidProject) { |
| val variant = myLintProject.currentVariant |
| if (variant != null) { |
| return variant.mainArtifact.dependencies |
| } |
| } |
| return null |
| } |
| |
| override fun extendsClass(cls: PsiClass?, className: String, strict: Boolean): Boolean { |
| // TODO: This checks interfaces too. Let's find a cheaper method which only checks direct super classes! |
| return InheritanceUtil.isInheritor(cls, strict, className) |
| } |
| |
| override fun implementsInterface( |
| cls: PsiClass, |
| interfaceName: String, |
| strict: Boolean |
| ): Boolean { |
| // TODO: This checks superclasses too. Let's find a cheaper method which only checks interfaces. |
| return InheritanceUtil.isInheritor(cls, strict, interfaceName) |
| } |
| |
| override fun inheritsFrom(cls: PsiClass, className: String, strict: Boolean): Boolean { |
| return InheritanceUtil.isInheritor(cls, strict, className) |
| } |
| |
| override fun findClass(qualifiedName: String): PsiClass? { |
| return JavaPsiFacade.getInstance(myProject ?: return null).findClass( |
| qualifiedName, |
| GlobalSearchScope.allScope(myProject) |
| ) |
| } |
| |
| override fun getClassType(psiClass: PsiClass?): PsiClassType? { |
| return if (myProject != null && psiClass != null) |
| JavaPsiFacade.getElementFactory(myProject).createType(psiClass) |
| else null |
| } |
| |
| override fun getAllAnnotations( |
| owner: UAnnotated, |
| inHierarchy: Boolean |
| ): List<UAnnotation> { |
| if (owner is UDeclaration) { |
| // Going to PSI means we drop vital context from Kotlin annotations. |
| // Therefore, call into UAST to get the full Kotlin annotations, but also |
| // merge in external annotations and inherited annotations from the class |
| // files, and pick unique. |
| val annotations = owner.annotations |
| val psiAnnotations = getAllAnnotations(owner.psi, inHierarchy) |
| |
| if (!annotations.isEmpty()) { |
| if (psiAnnotations.isEmpty()) { |
| return annotations |
| } |
| |
| // Filter with preference given to the builtins |
| val result = mutableListOf<UAnnotation>() |
| for (psi in psiAnnotations) { |
| val signature = psi.qualifiedName |
| var handled = false |
| for (ua in annotations) { |
| if (ua.qualifiedName == signature) { |
| result.add(ua) |
| handled = true |
| break |
| } |
| } |
| if (!handled) { |
| result.add(JavaUAnnotation.wrap(psi)) |
| } |
| } |
| |
| return result |
| } |
| |
| // Work around bug: Passing in a UAST node to this method generates a |
| // "class JavaUParameter not found among parameters: [PsiParameter:something]" error |
| return JavaUAnnotation.wrap(psiAnnotations) |
| } |
| |
| return owner.annotations |
| } |
| |
| override fun getAllAnnotations( |
| owner: PsiModifierListOwner, |
| inHierarchy: Boolean |
| ): Array<PsiAnnotation> { |
| if (owner is UDeclaration) { |
| // Work around bug: Passing in a UAST node to this method generates a |
| // "class JavaUParameter not found among parameters: [PsiParameter:something]" error |
| return getAllAnnotations(owner.psi, inHierarchy) |
| } |
| |
| // withInferred=false when running outside the IDE: we don't have |
| // an InferredAnnotationsManager |
| return AnnotationUtil.getAllAnnotations(owner, inHierarchy, null, false) |
| } |
| |
| override fun findAnnotationInHierarchy( |
| listOwner: PsiModifierListOwner, |
| vararg annotationNames: String |
| ): PsiAnnotation? { |
| if (listOwner is UDeclaration) { |
| // Work around UAST bug |
| return findAnnotationInHierarchy(listOwner.psi, *annotationNames) |
| } |
| return AnnotationUtil.findAnnotationInHierarchy( |
| listOwner, |
| Sets.newHashSet(*annotationNames) |
| ) |
| } |
| |
| override fun findAnnotation( |
| listOwner: PsiModifierListOwner?, |
| vararg annotationNames: String |
| ): PsiAnnotation? { |
| if (listOwner is UDeclaration) { |
| // Work around UAST bug |
| return findAnnotation(listOwner.psi, *annotationNames) |
| } |
| return AnnotationUtil.findAnnotation(listOwner, false, *annotationNames) |
| } |
| |
| override fun areSignaturesEqual(method1: PsiMethod, method2: PsiMethod): Boolean { |
| return MethodSignatureUtil.areSignaturesEqual(method1, method2) |
| } |
| |
| override fun findJarPath(element: PsiElement): String? { |
| val containingFile = element.containingFile |
| @Suppress("USELESS_CAST") |
| return findJarPath(containingFile as PsiFile?) |
| } |
| |
| override fun findJarPath(element: UElement): String? { |
| val uFile = element.getContainingUFile() |
| return if (uFile != null) findJarPath(uFile.psi as PsiFile?) else null |
| } |
| |
| private fun findJarPath(containingFile: PsiFile?): String? { |
| if (containingFile is PsiCompiledFile) { |
| // This code is roughly similar to the following: |
| // VirtualFile jarVirtualFile = PsiUtil.getJarFile(containingFile); |
| // if (jarVirtualFile != null) { |
| // return jarVirtualFile.getPath(); |
| // } |
| // However, the above methods will do some extra string manipulation and |
| // VirtualFile lookup which we don't actually need (we're just after the |
| // raw URL suffix) |
| val file = containingFile.virtualFile |
| if (file != null && file.fileSystem.protocol == URLUtil.JAR_PROTOCOL) { |
| val path = file.path |
| val separatorIndex = path.indexOf(URLUtil.JAR_SEPARATOR) |
| if (separatorIndex >= 0) { |
| return path.substring(0, separatorIndex) |
| } |
| } |
| } |
| |
| return null |
| } |
| |
| override fun getPackage(node: PsiElement): PsiPackage? { |
| val containingFile = node as? PsiFile ?: node.containingFile |
| if (containingFile != null) { |
| // Optimization: JavaDirectoryService can be slow so try to compute it directly |
| if (containingFile is PsiJavaFile) { |
| return packageInfoCache.computeIfAbsent(containingFile.packageName) { name -> |
| val cls = findClass(name + '.' + PsiPackage.PACKAGE_INFO_CLASS) |
| val modifierList = cls?.modifierList |
| object : PsiPackageImpl(node.manager, name) { |
| override fun getAnnotationList(): PsiModifierList? { |
| return if (modifierList != null) { |
| // Use composite even if we just have one such that we don't |
| // pass a modifier list tied to source elements in the class |
| // (modifier lists can be part of the AST) |
| PsiCompositeModifierList( |
| manager, |
| listOf(modifierList) |
| ) |
| } else null |
| } |
| } |
| } |
| } |
| |
| val dir = containingFile.parent |
| if (dir != null) { |
| return JavaDirectoryService.getInstance().getPackage(dir) |
| } |
| } |
| return null |
| } |
| |
| override fun getPackage(node: UElement): PsiPackage? { |
| val uFile = node.getContainingUFile() |
| return if (uFile != null) { |
| getPackage(uFile.psi) |
| } else null |
| } |
| |
| override fun getQualifiedName(psiClassType: PsiClassType): String? { |
| val erased = erasure(psiClassType) |
| return if (erased is PsiClassType) { |
| super.getQualifiedName((erased as PsiClassType?)!!) |
| } else super.getQualifiedName(psiClassType) |
| } |
| |
| override fun getQualifiedName(psiClass: PsiClass): String? { |
| return psiClass.qualifiedName |
| } |
| |
| @Suppress("OverridingDeprecatedMember", "DEPRECATION") |
| override fun getInternalName(psiClassType: PsiClassType): String? { |
| val erased = erasure(psiClassType) |
| return if (erased is PsiClassType) { |
| super.getInternalName((erased as PsiClassType?)!!) |
| } else super.getInternalName(psiClassType) |
| } |
| |
| @Suppress("OverridingDeprecatedMember") |
| override fun getInternalName(psiClass: PsiClass): String? { |
| return com.android.tools.lint.detector.api.getInternalName(psiClass) |
| } |
| |
| override fun erasure(type: PsiType?): PsiType? { |
| return TypeConversionUtil.erasure(type) |
| } |
| |
| override fun computeArgumentMapping(call: UCallExpression, method: PsiMethod): |
| Map<UExpression, PsiParameter> { |
| val parameterList = method.parameterList |
| if (parameterList.parametersCount == 0) { |
| return emptyMap() |
| } |
| |
| // Call into lint-kotlin to look up the argument mapping if this call is a Kotlin method. |
| val kotlinMap = computeKotlinArgumentMapping(call, method) |
| if (kotlinMap != null) { |
| return kotlinMap |
| } |
| |
| val arguments = call.valueArguments |
| val parameters = parameterList.parameters |
| |
| var j = 0 |
| if (parameters.isNotEmpty() && "\$receiver" == parameters[0].name && |
| isKotlin(call.sourcePsi) |
| ) { |
| // Kotlin extension method. |
| j++ |
| } |
| |
| var i = 0 |
| val n = Math.min(parameters.size, arguments.size) |
| val map = HashMap<UExpression, PsiParameter>(2 * n) |
| |
| /* Here is a UAST supported way to compute this, but it doesn't handle |
| varargs well (some unit tests fail showing the particular scenarios) |
| if (call is UCallExpressionEx) { |
| for (index in 0 until parameters.size) { |
| val argument = call.getArgumentForParameter(index) ?: continue |
| val parameter = parameters[index] |
| map[argument] = parameter |
| } |
| |
| return map |
| } |
| */ |
| |
| while (j < n) { |
| val argument = arguments[i] |
| val parameter = parameters[j] |
| map[argument] = parameter |
| i++ |
| j++ |
| } |
| |
| if (i < arguments.size && j > 0) { |
| // last parameter is varargs (same parameter annotations) |
| j-- |
| while (i < arguments.size) { |
| val argument = arguments[i] |
| val parameter = parameters[j] |
| map[argument] = parameter |
| i++ |
| } |
| } |
| |
| return map |
| } |
| } |
