From 27efc3b202eef37eccd7eb1b5840bb2c8ef46344 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 25 Jul 2013 15:23:05 +0400 Subject: [PATCH] Additional resolve for annotations in lazy resolve --- .../resolve/lazy/ResolveSessionUtils.java | 21 +++++++++++++++++-- .../lazy/descriptors/LazyClassDescriptor.java | 2 +- .../resolve/references/AnnotationForClass.kt | 7 +++++++ .../references/AnnotationInsideFunction.kt | 10 +++++++++ .../resolve/references/AnnotationParameter.kt | 9 ++++++++ .../references/AnnotationTypeParameter.kt | 9 ++++++++ .../ReferenceResolveTestGenerated.java | 20 ++++++++++++++++++ 7 files changed, 75 insertions(+), 3 deletions(-) create mode 100644 idea/testData/resolve/references/AnnotationForClass.kt create mode 100644 idea/testData/resolve/references/AnnotationInsideFunction.kt create mode 100644 idea/testData/resolve/references/AnnotationParameter.kt create mode 100644 idea/testData/resolve/references/AnnotationTypeParameter.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java index d477e953e82..4c41659151c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java @@ -27,6 +27,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.di.InjectorForBodyResolve; import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.annotations.Annotated; import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorBase; import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor; import org.jetbrains.jet.lang.psi.*; @@ -119,15 +120,17 @@ public class ResolveSessionUtils { ) { DelegatingBindingTrace trace = new DelegatingBindingTrace( resolveSession.getBindingContext(), "trace to resolve jetElement", jetElement); - JetFile file = (JetFile) jetElement.getContainingFile(); + // All additional resolve should be done to separate trace @SuppressWarnings("unchecked") PsiElement topmostCandidateForAdditionalResolve = JetPsiUtil.getTopmostParentOfTypes(jetElement, JetNamedFunction.class, JetClassInitializer.class, JetProperty.class, JetDelegationSpecifierList.class, - JetImportDirective.class); + JetImportDirective.class, JetAnnotationEntry.class); if (topmostCandidateForAdditionalResolve != null) { + JetFile file = (JetFile) jetElement.getContainingFile(); + if (topmostCandidateForAdditionalResolve instanceof JetNamedFunction) { functionAdditionalResolve(resolveSession, (JetNamedFunction) topmostCandidateForAdditionalResolve, trace, file); } @@ -148,6 +151,10 @@ public class ResolveSessionUtils { // Get all descriptors to force resolving all imports scope.getAllDescriptors(); } + else if (topmostCandidateForAdditionalResolve instanceof JetAnnotationEntry) { + annotationAdditionalResolve(resolveSession, (JetAnnotationEntry) topmostCandidateForAdditionalResolve); + return resolveSession.getBindingContext(); + } else { assert false : "Invalid type of the topmost parent"; } @@ -169,6 +176,16 @@ public class ResolveSessionUtils { return trace.getBindingContext(); } + private static void annotationAdditionalResolve(KotlinCodeAnalyzer analyzer, JetAnnotationEntry jetAnnotationEntry) { + JetDeclaration declaration = PsiTreeUtil.getParentOfType(jetAnnotationEntry, JetDeclaration.class); + if (declaration != null) { + Annotated descriptor = analyzer.resolveToDescriptor(declaration); + + // Activate annotation resolving + descriptor.getAnnotations(); + } + } + private static void delegationSpecifierAdditionalResolve( KotlinCodeAnalyzer analyzer, JetDelegationSpecifierList specifier, DelegatingBindingTrace trace, JetFile file) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java index 48112f4bc74..708005af8ef 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java @@ -352,7 +352,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc if (modifierList != null) { AnnotationResolver annotationResolver = resolveSession.getInjector().getAnnotationResolver(); JetScope scopeForDeclaration = getScopeProvider().getResolutionScopeForDeclaration(classInfo.getScopeAnchor()); - return annotationResolver.resolveAnnotations(scopeForDeclaration, modifierList, resolveSession.getTrace()); + return annotationResolver.resolveAnnotationsWithArguments(scopeForDeclaration, modifierList, resolveSession.getTrace()); } else { return Collections.emptyList(); diff --git a/idea/testData/resolve/references/AnnotationForClass.kt b/idea/testData/resolve/references/AnnotationForClass.kt new file mode 100644 index 00000000000..e3cf0f84c9f --- /dev/null +++ b/idea/testData/resolve/references/AnnotationForClass.kt @@ -0,0 +1,7 @@ +package test + +annotation class Annotation + +Annotation class Some + +// REF: (test).Annotation diff --git a/idea/testData/resolve/references/AnnotationInsideFunction.kt b/idea/testData/resolve/references/AnnotationInsideFunction.kt new file mode 100644 index 00000000000..2b008b6bb5b --- /dev/null +++ b/idea/testData/resolve/references/AnnotationInsideFunction.kt @@ -0,0 +1,10 @@ +package test + +annotation class Annotation + +fun test() { + Annotation fun some() { + } +} + +// REF: (test).Annotation \ No newline at end of file diff --git a/idea/testData/resolve/references/AnnotationParameter.kt b/idea/testData/resolve/references/AnnotationParameter.kt new file mode 100644 index 00000000000..0d83eb9f042 --- /dev/null +++ b/idea/testData/resolve/references/AnnotationParameter.kt @@ -0,0 +1,9 @@ +package testing + +annotation class Annotation(val clazz: Class) +class ATest + +[Annotation(javaClass<ATest>())] +class BTest + +// REF: (testing).ATest \ No newline at end of file diff --git a/idea/testData/resolve/references/AnnotationTypeParameter.kt b/idea/testData/resolve/references/AnnotationTypeParameter.kt new file mode 100644 index 00000000000..687d6740c62 --- /dev/null +++ b/idea/testData/resolve/references/AnnotationTypeParameter.kt @@ -0,0 +1,9 @@ +package testing + +annotation class Annotation(val clazz: Class) +class ATest + +[Annotation<ATest>(javaClass())] +class BTest + +// REF: (testing).ATest \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/resolve/ReferenceResolveTestGenerated.java b/idea/tests/org/jetbrains/jet/resolve/ReferenceResolveTestGenerated.java index 7a6ebec4a6f..2b7d5d78ac8 100644 --- a/idea/tests/org/jetbrains/jet/resolve/ReferenceResolveTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/resolve/ReferenceResolveTestGenerated.java @@ -36,6 +36,26 @@ public class ReferenceResolveTestGenerated extends AbstractResolveBaseTest { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/resolve/references"), Pattern.compile("^(.+)\\.kt$"), true); } + @TestMetadata("AnnotationForClass.kt") + public void testAnnotationForClass() throws Exception { + doTest("idea/testData/resolve/references/AnnotationForClass.kt"); + } + + @TestMetadata("AnnotationInsideFunction.kt") + public void testAnnotationInsideFunction() throws Exception { + doTest("idea/testData/resolve/references/AnnotationInsideFunction.kt"); + } + + @TestMetadata("AnnotationParameter.kt") + public void testAnnotationParameter() throws Exception { + doTest("idea/testData/resolve/references/AnnotationParameter.kt"); + } + + @TestMetadata("AnnotationTypeParameter.kt") + public void testAnnotationTypeParameter() throws Exception { + doTest("idea/testData/resolve/references/AnnotationTypeParameter.kt"); + } + @TestMetadata("ClassReferenceInImport.kt") public void testClassReferenceInImport() throws Exception { doTest("idea/testData/resolve/references/ClassReferenceInImport.kt");