From 04bef2cc080df71275f92eca84d353441a34694b Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Tue, 2 Jun 2015 19:14:27 +0300 Subject: [PATCH] Minor: Drop unused code and inline utility --- .../kotlin/resolve/AnnotationUtil.kt | 3 - .../validation/DeprecatedSymbolValidator.kt | 5 +- .../DeprecatedAnnotationVisitor.java | 255 ------------------ 3 files changed, 1 insertion(+), 262 deletions(-) delete mode 100644 idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DeprecatedAnnotationVisitor.java diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt index 787fffb3c24..74ea88afe34 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt @@ -57,6 +57,3 @@ public fun AnnotationDescriptor.argumentValue(parameterName: String): Any? { .singleOrNull { it.key.getName().asString() == parameterName } ?.value?.getValue() } - -public fun AnnotationDescriptor.deprecatedAnnotationMessage(): String? - = argumentValue("value") as? String diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt index 18edc230859..11cc047dfe3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt @@ -26,12 +26,9 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.lexer.JetTokens import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.BindingTrace -import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.annotations.argumentValue -import org.jetbrains.kotlin.resolve.annotations.deprecatedAnnotationMessage public class DeprecatedSymbolValidator : SymbolUsageValidator { private val JAVA_DEPRECATED = FqName(javaClass().getName()) @@ -91,7 +88,7 @@ public class DeprecatedSymbolValidator : SymbolUsageValidator { } private fun createDeprecationDiagnostic(element: PsiElement, descriptor: DeclarationDescriptor, deprecated: AnnotationDescriptor): Diagnostic { - val message = deprecated.deprecatedAnnotationMessage() + val message = deprecated.argumentValue("value") as? String return if (message == null) Errors.DEPRECATED_SYMBOL.on(element, descriptor) else diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DeprecatedAnnotationVisitor.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DeprecatedAnnotationVisitor.java deleted file mode 100644 index 67e7e55ba6c..00000000000 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DeprecatedAnnotationVisitor.java +++ /dev/null @@ -1,255 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * 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 org.jetbrains.kotlin.idea.highlighter; - -import com.intellij.lang.annotation.AnnotationHolder; -import com.intellij.openapi.editor.colors.CodeInsightColors; -import com.intellij.psi.PsiElement; -import com.intellij.psi.tree.IElementType; -import com.intellij.psi.tree.TokenSet; -import com.intellij.psi.util.PsiTreeUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.JetNodeTypes; -import org.jetbrains.kotlin.builtins.KotlinBuiltIns; -import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.kotlin.lexer.JetTokens; -import org.jetbrains.kotlin.name.FqName; -import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.renderer.DescriptorRenderer; -import org.jetbrains.kotlin.resolve.BindingContext; -import org.jetbrains.kotlin.resolve.DescriptorUtils; -import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage; -import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage; -import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; -import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall; - -public class DeprecatedAnnotationVisitor extends AfterAnalysisHighlightingVisitor { - - private static final TokenSet PROPERTY_SET_OPERATIONS = - TokenSet.create(JetTokens.EQ, JetTokens.PLUSEQ, JetTokens.MINUSEQ, JetTokens.MULTEQ, - JetTokens.DIVEQ, JetTokens.PERCEQ, JetTokens.PLUSPLUS, JetTokens.MINUSMINUS); - private static final FqName JAVA_DEPRECATED = new FqName(Deprecated.class.getName()); - - protected DeprecatedAnnotationVisitor(AnnotationHolder holder, BindingContext bindingContext) { - super(holder, bindingContext); - } - - @Override - public void visitSuperExpression(@NotNull JetSuperExpression expression) { - // Deprecated for super expression. Unnecessary to mark it as Deprecated - } - - @Override - public void visitReferenceExpression(@NotNull JetReferenceExpression expression) { - super.visitReferenceExpression(expression); - - if (expression.getParent() instanceof JetThisExpression) { - return; - } - - ResolvedCall resolvedCall = CallUtilPackage.getResolvedCall(expression, bindingContext); - if (resolvedCall != null && resolvedCall instanceof VariableAsFunctionResolvedCall) { - // Deprecated for invoke() - JetCallExpression parent = PsiTreeUtil.getParentOfType(expression, JetCallExpression.class); - if (parent != null) { - reportAnnotationIfNeeded(parent, resolvedCall.getResultingDescriptor(), true); - } - } - if (expression.getNode().getElementType() == JetNodeTypes.OPERATION_REFERENCE) { - // Deprecated for operations (mark as warning) - checkDeprecatedForOperations(expression); - } - else { - checkDeprecatedForReferenceExpression(expression); - } - } - - private void checkDeprecatedForReferenceExpression(@NotNull JetReferenceExpression expression) { - DeclarationDescriptor target = bindingContext.get(BindingContext.REFERENCE_TARGET, expression); - if (target != null) { - if (target instanceof ConstructorDescriptor) { - checkConstructorDescriptor(expression, target); - } - else if (target instanceof ClassDescriptor) { - checkClassDescriptor(expression, (ClassDescriptor) target); - } - else if (target instanceof PropertyDescriptor) { - checkPropertyDescriptor(expression, (PropertyDescriptor) target); - } - else if (target instanceof FunctionDescriptor) { - checkFunctionDescriptor(expression, target); - } - } - } - - private void checkFunctionDescriptor(JetExpression expression, DeclarationDescriptor target) { - // Deprecated for Function - reportAnnotationIfNeeded(expression, target, expression instanceof JetArrayAccessExpression); - } - - private void checkConstructorDescriptor(@NotNull JetExpression expression, @NotNull DeclarationDescriptor target) { - // Deprecated for Class and for Constructor - DeclarationDescriptor containingDeclaration = target.getContainingDeclaration(); - if (containingDeclaration != null) { - if (!reportAnnotationIfNeeded(expression, containingDeclaration)) { - reportAnnotationIfNeeded(expression, target); - } - } - } - - private void checkClassDescriptor(@NotNull JetExpression expression, @NotNull ClassDescriptor target) { - reportAnnotationIfNeeded(expression, target); - } - - private void checkPropertyDescriptor( - @NotNull JetExpression expression, - @NotNull PropertyDescriptor propertyDescriptor - ) { - // Deprecated for Property - if (reportAnnotationIfNeeded(expression, propertyDescriptor, propertyDescriptor.isVar())) { - return; - } - - // Deprecated for Getter (val, var), Setter (var) - if (!propertyDescriptor.isVar()) { - checkPropertyGetter(propertyDescriptor, expression); - } - else { - IElementType operation = null; - JetBinaryExpression binaryExpression = PsiTreeUtil.getParentOfType(expression, JetBinaryExpression.class); - if (binaryExpression != null) { - JetExpression left = binaryExpression.getLeft(); - if (left == expression) { - operation = binaryExpression.getOperationToken(); - } - else { - JetReferenceExpression[] jetReferenceExpressions = PsiTreeUtil.getChildrenOfType(left, JetReferenceExpression.class); - if (jetReferenceExpressions != null) { - for (JetReferenceExpression expr : jetReferenceExpressions) { - if (expr == expression) { - operation = binaryExpression.getOperationToken(); - break; - } - } - } - } - } - else { - JetUnaryExpression unaryExpression = PsiTreeUtil.getParentOfType(expression, JetUnaryExpression.class); - if (unaryExpression != null) { - operation = unaryExpression.getOperationReference().getReferencedNameElementType(); - } - } - - if (operation != null && PROPERTY_SET_OPERATIONS.contains(operation)) { - checkPropertySetter(propertyDescriptor, expression); - } - else { - checkPropertyGetter(propertyDescriptor, expression); - } - } - } - - private void checkPropertySetter(@NotNull PropertyDescriptor descriptor, @NotNull JetExpression expression) { - PropertySetterDescriptor setter = descriptor.getSetter(); - if (setter != null) { - checkPropertyAccessor(setter, expression, true); - } - } - - private void checkPropertyGetter(@NotNull PropertyDescriptor descriptor, @NotNull JetExpression expression) { - PropertyGetterDescriptor getter = descriptor.getGetter(); - if (getter != null) { - checkPropertyAccessor(getter, expression, descriptor.isVar()); - } - } - - private void checkPropertyAccessor( - @NotNull PropertyAccessorDescriptor accessor, - @NotNull JetExpression expression, boolean isCrossingDisallowed - ) { - reportAnnotationIfNeeded(expression, accessor, isCrossingDisallowed); - } - - private void checkDeprecatedForOperations(@NotNull JetReferenceExpression expression) { - DeclarationDescriptor target = bindingContext.get(BindingContext.REFERENCE_TARGET, expression); - if (target != null) { - reportAnnotationIfNeeded(expression, target, true); - } - } - - private boolean reportAnnotationIfNeeded(@NotNull PsiElement element, @NotNull DeclarationDescriptor descriptor) { - return reportAnnotationIfNeeded(element, descriptor, false); - } - - private boolean reportAnnotationIfNeeded(@NotNull PsiElement element, @NotNull DeclarationDescriptor descriptor, boolean isCrossingDisallowed) { - AnnotationDescriptor deprecated = getDeprecated(descriptor); - if (deprecated != null) { - if (isCrossingDisallowed) { - holder.createWarningAnnotation(element, composeTooltipString(descriptor, deprecated)) - .setTextAttributes(CodeInsightColors.WARNINGS_ATTRIBUTES); - } - else { - holder.createWarningAnnotation(element, composeTooltipString(descriptor, deprecated)) - .setTextAttributes(CodeInsightColors.DEPRECATED_ATTRIBUTES); - } - return true; - } - return false; - } - - @Nullable - private static AnnotationDescriptor getDeprecated(DeclarationDescriptor descriptor) { - AnnotationDescriptor kotlinDeprecated = descriptor.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.deprecated); - return kotlinDeprecated != null ? kotlinDeprecated : descriptor.getAnnotations().findAnnotation(JAVA_DEPRECATED); - } - - private static String composeTooltipString(@NotNull DeclarationDescriptor declarationDescriptor, @NotNull AnnotationDescriptor descriptor) { - String fact = "'" + getDescriptorString(declarationDescriptor) + "' is deprecated."; - String message = AnnotationsPackage.deprecatedAnnotationMessage(descriptor); - return message == null ? fact : fact + " " + message; - } - - private static String getDescriptorString(@NotNull DeclarationDescriptor descriptor) { - if (descriptor instanceof ClassDescriptor) { - return DescriptorUtils.getFqName(descriptor).asString(); - } - else if (descriptor instanceof ConstructorDescriptor) { - DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - assert containingDeclaration != null; - return "constructor for " + containingDeclaration.getName(); - } - else if (descriptor instanceof PropertyGetterDescriptor) { - return "getter for " + ((PropertyGetterDescriptor) descriptor).getCorrespondingProperty().getName(); - } - else if (descriptor instanceof PropertySetterDescriptor) { - return "setter for " + ((PropertySetterDescriptor) descriptor).getCorrespondingProperty().getName(); - } - else if (descriptor instanceof PropertyDescriptor) { - if (((PropertyDescriptor) descriptor).isVar()) { - return "var " + descriptor.getName(); - } - return "val " + descriptor.getName(); - } - else if (descriptor instanceof FunctionDescriptor) { - return "fun " + descriptor.getName() + DescriptorRenderer.FQ_NAMES_IN_TYPES.renderFunctionParameters((FunctionDescriptor) descriptor); - } - return DescriptorRenderer.FQ_NAMES_IN_TYPES.render(descriptor); - } -}