From 787b4753c7973cfe7763c4e813a9256ec026f761 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 27 Feb 2014 22:35:18 +0400 Subject: [PATCH] Copy KotlinSignature to package "kotlin.jvm" Support both KotlinSignature classes in the compiler and in the IDEA plugin. The old one will be deprecated later and dropped eventually --- .../java/kotlinSignature/SignaturesUtil.java | 27 +++++++++++-------- .../IdeaJdkAnnotationsReflectedTest.java | 4 +-- .../lang/resolve/java/JvmAnnotationNames.java | 4 ++- .../src/kotlin/jvm/KotlinSignature.java | 25 +++++++++++++++++ .../ktSignature/DeleteSignatureAction.java | 10 ++++--- .../ktSignature/EditSignatureAction.java | 4 ++- .../ktSignature/EditSignatureBalloon.java | 24 +++++++++++------ .../KotlinSignatureAnnotationIntention.java | 6 +++-- .../ktSignature/KotlinSignatureUtil.java | 24 +++++++++++------ 9 files changed, 92 insertions(+), 36 deletions(-) create mode 100644 core/runtime.jvm/src/kotlin/jvm/KotlinSignature.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java index feece12d130..f56356b25ed 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java @@ -23,8 +23,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.ExternalAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.structure.*; import org.jetbrains.jet.lang.resolve.name.FqName; -import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME; -import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.KOTLIN_SIGNATURE; +import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.*; public class SignaturesUtil { private SignaturesUtil() { @@ -32,18 +31,24 @@ public class SignaturesUtil { @Nullable public static String getKotlinSignature(@NotNull ExternalAnnotationResolver externalAnnotationResolver, @NotNull JavaMember member) { - JavaAnnotation annotation = findAnnotationWithExternal(externalAnnotationResolver, member, KOTLIN_SIGNATURE); + JavaAnnotation newAnnotation = findAnnotationWithExternal(externalAnnotationResolver, member, KOTLIN_SIGNATURE); + if (newAnnotation != null) return extractKotlinSignatureArgument(newAnnotation); - if (annotation != null) { - JavaAnnotationArgument argument = annotation.findArgument(DEFAULT_ANNOTATION_MEMBER_NAME); - if (argument instanceof JavaLiteralAnnotationArgument) { - Object value = ((JavaLiteralAnnotationArgument) argument).getValue(); - if (value instanceof String) { - return StringUtil.unescapeStringCharacters((String) value); - } + JavaAnnotation oldAnnotation = findAnnotationWithExternal(externalAnnotationResolver, member, OLD_KOTLIN_SIGNATURE); + if (oldAnnotation != null) return extractKotlinSignatureArgument(oldAnnotation); + + return null; + } + + @Nullable + private static String extractKotlinSignatureArgument(@NotNull JavaAnnotation annotation) { + JavaAnnotationArgument argument = annotation.findArgument(DEFAULT_ANNOTATION_MEMBER_NAME); + if (argument instanceof JavaLiteralAnnotationArgument) { + Object value = ((JavaLiteralAnnotationArgument) argument).getValue(); + if (value instanceof String) { + return StringUtil.unescapeStringCharacters((String) value); } } - return null; } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java index b14f183656e..c6479b017c6 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java @@ -166,9 +166,9 @@ public class IdeaJdkAnnotationsReflectedTest extends KotlinTestWithEnvironment { } private enum AnnotationsKind { - KOTLIN_SIGNATURE(JvmAnnotationNames.KOTLIN_SIGNATURE.asString()), + KOTLIN_SIGNATURE(JvmAnnotationNames.KOTLIN_SIGNATURE.asString(), JvmAnnotationNames.OLD_KOTLIN_SIGNATURE.asString()), NOT_NULL(AnnotationUtil.NOT_NULL), - ANY(AnnotationUtil.NOT_NULL, JvmAnnotationNames.KOTLIN_SIGNATURE.asString()); + ANY(AnnotationUtil.NOT_NULL, JvmAnnotationNames.KOTLIN_SIGNATURE.asString(), JvmAnnotationNames.OLD_KOTLIN_SIGNATURE.asString()); public final String[] annotationNames; diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmAnnotationNames.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmAnnotationNames.java index 9004f378fdd..4ce96156f54 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmAnnotationNames.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmAnnotationNames.java @@ -26,7 +26,8 @@ public final class JvmAnnotationNames { public static final FqName KOTLIN_PACKAGE_PART = new FqName("kotlin.jvm.internal.KotlinPackagePart"); public static final FqName KOTLIN_TRAIT_IMPL = new FqName("kotlin.jvm.internal.KotlinTraitImpl"); - public static final FqName KOTLIN_SIGNATURE = new FqName("jet.runtime.typeinfo.KotlinSignature"); + public static final FqName KOTLIN_SIGNATURE = new FqName("kotlin.jvm.KotlinSignature"); + public static final FqName OLD_KOTLIN_SIGNATURE = new FqName("jet.runtime.typeinfo.KotlinSignature"); public static final String ABI_VERSION_FIELD_NAME = "abiVersion"; public static final String DATA_FIELD_NAME = "data"; @@ -55,6 +56,7 @@ public final class JvmAnnotationNames { @SuppressWarnings("deprecation") public static boolean isSpecialAnnotation(@NotNull FqName fqName) { return fqName.asString().startsWith("jet.runtime.typeinfo.") + || fqName.equals(KOTLIN_SIGNATURE) || fqName.equals(JETBRAINS_NOT_NULL_ANNOTATION) || fqName.equals(OLD_KOTLIN_CLASS) || fqName.equals(OLD_KOTLIN_PACKAGE) diff --git a/core/runtime.jvm/src/kotlin/jvm/KotlinSignature.java b/core/runtime.jvm/src/kotlin/jvm/KotlinSignature.java new file mode 100644 index 00000000000..96dd5b05d91 --- /dev/null +++ b/core/runtime.jvm/src/kotlin/jvm/KotlinSignature.java @@ -0,0 +1,25 @@ +/* + * Copyright 2010-2014 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 kotlin.jvm; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +@Target({ElementType.METHOD, ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.FIELD}) +public @interface KotlinSignature { + String value(); +} diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/DeleteSignatureAction.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/DeleteSignatureAction.java index dc9df7b0b70..c79dffd8621 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/DeleteSignatureAction.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/DeleteSignatureAction.java @@ -26,6 +26,9 @@ import com.intellij.psi.PsiAnnotation; import com.intellij.psi.PsiModifierListOwner; import org.jetbrains.annotations.NotNull; +import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.KOTLIN_SIGNATURE; +import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.OLD_KOTLIN_SIGNATURE; + public class DeleteSignatureAction extends AnAction { private final PsiModifierListOwner annotationOwner; @@ -47,15 +50,16 @@ public class DeleteSignatureAction extends AnAction { // external annotation new WriteCommandAction(project) { @Override - protected void run(Result result) throws Throwable { - ExternalAnnotationsManager.getInstance(project).deannotate(annotationOwner, KotlinSignatureUtil.KOTLIN_SIGNATURE_ANNOTATION); + protected void run(@NotNull Result result) throws Throwable { + ExternalAnnotationsManager.getInstance(project).deannotate(annotationOwner, KOTLIN_SIGNATURE.asString()); + ExternalAnnotationsManager.getInstance(project).deannotate(annotationOwner, OLD_KOTLIN_SIGNATURE.asString()); } }.execute(); } else { new WriteCommandAction(project) { @Override - protected void run(Result result) throws Throwable { + protected void run(@NotNull Result result) throws Throwable { annotation.delete(); } }.execute(); diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/EditSignatureAction.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/EditSignatureAction.java index e48c5627a56..7fdbe844423 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/EditSignatureAction.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/EditSignatureAction.java @@ -75,7 +75,9 @@ public class EditSignatureAction extends AnAction { else { PsiModifierListOwner annotationOwner = KotlinSignatureUtil.getAnnotationOwner(elementInEditor); boolean editable = KotlinSignatureUtil.isAnnotationEditable(elementInEditor); - EditSignatureBalloon balloon = new EditSignatureBalloon(annotationOwner, KotlinSignatureUtil.getKotlinSignature(annotation), editable); + //noinspection ConstantConditions + EditSignatureBalloon balloon = new EditSignatureBalloon(annotationOwner, KotlinSignatureUtil.getKotlinSignature(annotation), + editable, annotation.getQualifiedName()); balloon.show(point, editor, elementInEditor); } } diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/EditSignatureBalloon.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/EditSignatureBalloon.java index 1366643086c..6997495eac5 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/EditSignatureBalloon.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/EditSignatureBalloon.java @@ -62,13 +62,20 @@ class EditSignatureBalloon implements Disposable { private final MyPanel panel; private final Balloon balloon; private final boolean editable; + private final String kotlinSignatureAnnotationFqName; - public EditSignatureBalloon(@NotNull PsiModifierListOwner annotatedElement, @NotNull String previousSignature, boolean editable) { + public EditSignatureBalloon( + @NotNull PsiModifierListOwner annotatedElement, + @NotNull String previousSignature, + boolean editable, + @NotNull String kotlinSignatureAnnotationFqName + ) { this.annotatedElement = annotatedElement; - this.editable = editable; - project = annotatedElement.getProject(); this.previousSignature = previousSignature; + this.editable = editable; + this.kotlinSignatureAnnotationFqName = kotlinSignatureAnnotationFqName; + project = annotatedElement.getProject(); editor = createEditor(); panel = new MyPanel(); balloon = createBalloon(); @@ -174,10 +181,11 @@ class EditSignatureBalloon implements Disposable { new WriteCommandAction(project) { @Override - protected void run(Result result) throws Throwable { + protected void run(@NotNull Result result) throws Throwable { ExternalAnnotationsManager.getInstance(project).editExternalAnnotation( - annotatedElement, KotlinSignatureUtil.KOTLIN_SIGNATURE_ANNOTATION, KotlinSignatureUtil - .signatureToNameValuePairs(project, newSignature)); + annotatedElement, kotlinSignatureAnnotationFqName, + KotlinSignatureUtil.signatureToNameValuePairs(project, newSignature) + ); } }.execute(); } @@ -207,7 +215,7 @@ class EditSignatureBalloon implements Disposable { ActionListener saveAndHideListener = new ActionListener() { @Override - public void actionPerformed(ActionEvent e) { + public void actionPerformed(@NotNull ActionEvent e) { saveAndHide(); } }; @@ -222,7 +230,7 @@ class EditSignatureBalloon implements Disposable { registerKeyboardAction(new ActionListener() { @Override - public void actionPerformed(ActionEvent e) { + public void actionPerformed(@NotNull ActionEvent e) { balloon.hide(); } }, KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), JComponent.WHEN_IN_FOCUSED_WINDOW); diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java index 03f44e14dab..33c76cf375f 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java @@ -49,6 +49,8 @@ import org.jetbrains.jet.renderer.DescriptorRendererBuilder; import javax.swing.*; +import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.KOTLIN_SIGNATURE; + public class KotlinSignatureAnnotationIntention extends BaseIntentionAction implements Iconable { private static final DescriptorRenderer RENDERER = new DescriptorRendererBuilder() .setShortNames(true) @@ -113,7 +115,7 @@ public class KotlinSignatureAnnotationIntention extends BaseIntentionAction impl public void afterExternalAnnotationChanging(@NotNull PsiModifierListOwner owner, @NotNull String annotationFQName, boolean successful) { busConnection.disconnect(); - if (successful && owner == annotatedElement && KotlinSignatureUtil.KOTLIN_SIGNATURE_ANNOTATION.equals(annotationFQName)) { + if (successful && owner == annotatedElement && KOTLIN_SIGNATURE.asString().equals(annotationFQName)) { ApplicationManager.getApplication().invokeLater(new Runnable() { @Override public void run() { @@ -126,7 +128,7 @@ public class KotlinSignatureAnnotationIntention extends BaseIntentionAction impl }); AddAnnotationFix addAnnotationFix = new AddAnnotationFix( - KotlinSignatureUtil.KOTLIN_SIGNATURE_ANNOTATION, annotatedElement, KotlinSignatureUtil + KOTLIN_SIGNATURE.asString(), annotatedElement, KotlinSignatureUtil .signatureToNameValuePairs(annotatedElement.getProject(), signature)); addAnnotationFix.invoke(project, editor, file); } diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java index 51c1ce68856..361beb77572 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java @@ -29,10 +29,9 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver; import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.KOTLIN_SIGNATURE; +import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.OLD_KOTLIN_SIGNATURE; class KotlinSignatureUtil { - static final String KOTLIN_SIGNATURE_ANNOTATION = KOTLIN_SIGNATURE.asString(); - private KotlinSignatureUtil() { } @@ -73,7 +72,7 @@ class KotlinSignatureUtil { @NotNull static PsiNameValuePair[] signatureToNameValuePairs(@NotNull Project project, @NotNull String signature) { return JavaPsiFacade.getElementFactory(project).createAnnotationFromText( - "@" + KOTLIN_SIGNATURE_ANNOTATION + "(value=\"" + StringUtil.escapeStringCharacters(signature) + "\")", null) + "@" + KOTLIN_SIGNATURE + "(value=\"" + StringUtil.escapeStringCharacters(signature) + "\")", null) .getParameterList().getAttributes(); } @@ -82,10 +81,18 @@ class KotlinSignatureUtil { if (!(element instanceof PsiModifierListOwner)) return null; PsiModifierListOwner annotationOwner = getAnnotationOwner(element); PsiModifierList list = annotationOwner.getModifierList(); - PsiAnnotation ownAnnotation = list == null ? null : list.findAnnotation(KOTLIN_SIGNATURE.asString()); - PsiAnnotation annotation = ownAnnotation != null - ? ownAnnotation - : PsiBasedExternalAnnotationResolver.findExternalAnnotation(annotationOwner, KOTLIN_SIGNATURE); + + PsiAnnotation annotation = list == null ? null : list.findAnnotation(KOTLIN_SIGNATURE.asString()); + if (annotation == null) { + annotation = PsiBasedExternalAnnotationResolver.findExternalAnnotation(annotationOwner, KOTLIN_SIGNATURE); + if (annotation == null) { + annotation = list == null ? null : list.findAnnotation(OLD_KOTLIN_SIGNATURE.asString()); + if (annotation == null) { + annotation = PsiBasedExternalAnnotationResolver.findExternalAnnotation(annotationOwner, OLD_KOTLIN_SIGNATURE); + } + } + } + if (annotation == null) return null; if (annotation.getParameterList().getAttributes().length == 0) return null; return annotation; @@ -103,7 +110,8 @@ class KotlinSignatureUtil { return annotation.isWritable(); } else { ExternalAnnotationsManager annotationsManager = ExternalAnnotationsManager.getInstance(element.getProject()); - return annotationsManager.isExternalAnnotationWritable(annotationOwner, KOTLIN_SIGNATURE_ANNOTATION); + //noinspection ConstantConditions + return annotationsManager.isExternalAnnotationWritable(annotationOwner, annotation.getQualifiedName()); } } }