diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index 5a009aa13f9..bf8aa4bec61 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -24,12 +24,13 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache; import org.jetbrains.jet.lang.resolve.java.resolver.FakeOverrideVisibilityResolverImpl; import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter; import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker; +import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver; import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; @@ -55,12 +56,13 @@ public class InjectorForJavaDescriptorResolver { private final FakeOverrideVisibilityResolverImpl fakeOverrideVisibilityResolver; private final TraceBasedErrorReporter traceBasedErrorReporter; private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker; + private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver; private final JavaDescriptorResolver javaDescriptorResolver; private final PsiClassFinderImpl psiClassFinder; private final VirtualFileFinder virtualFileFinder; - private final JavaClassResolver javaClassResolver; private final JavaAnnotationResolver javaAnnotationResolver; private final JavaAnnotationArgumentResolver javaAnnotationArgumentResolver; + private final JavaClassResolver javaClassResolver; private final DeserializedDescriptorResolver deserializedDescriptorResolver; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final JavaNamespaceResolver javaNamespaceResolver; @@ -85,12 +87,13 @@ public class InjectorForJavaDescriptorResolver { this.fakeOverrideVisibilityResolver = new FakeOverrideVisibilityResolverImpl(); this.traceBasedErrorReporter = new TraceBasedErrorReporter(); this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker(); + this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver(); this.javaDescriptorResolver = new JavaDescriptorResolver(); this.psiClassFinder = new PsiClassFinderImpl(); this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class); - this.javaClassResolver = new JavaClassResolver(); this.javaAnnotationResolver = new JavaAnnotationResolver(); this.javaAnnotationArgumentResolver = new JavaAnnotationArgumentResolver(); + this.javaClassResolver = new JavaClassResolver(); this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); this.javaNamespaceResolver = new JavaNamespaceResolver(); @@ -105,6 +108,7 @@ public class InjectorForJavaDescriptorResolver { javaClassFinder.setPsiClassFinder(psiClassFinder); + traceBasedExternalSignatureResolver.setAnnotationResolver(javaAnnotationResolver); traceBasedExternalSignatureResolver.setTrace(bindingTrace); traceBasedJavaResolverCache.setTrace(bindingTrace); @@ -113,6 +117,7 @@ public class InjectorForJavaDescriptorResolver { traceBasedErrorReporter.setTrace(bindingTrace); + psiBasedMethodSignatureChecker.setAnnotationResolver(javaAnnotationResolver); psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver); this.javaDescriptorResolver.setClassResolver(javaClassResolver); @@ -120,6 +125,13 @@ public class InjectorForJavaDescriptorResolver { this.psiClassFinder.setProject(project); + javaAnnotationResolver.setArgumentResolver(javaAnnotationArgumentResolver); + javaAnnotationResolver.setClassResolver(javaClassResolver); + javaAnnotationResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); + + javaAnnotationArgumentResolver.setAnnotationResolver(javaAnnotationResolver); + javaAnnotationArgumentResolver.setClassResolver(javaClassResolver); + javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setCache(traceBasedJavaResolverCache); javaClassResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver); @@ -131,12 +143,6 @@ public class InjectorForJavaDescriptorResolver { javaClassResolver.setTypeParameterResolver(javaTypeParameterResolver); javaClassResolver.setVirtualFileFinder(virtualFileFinder); - javaAnnotationResolver.setArgumentResolver(javaAnnotationArgumentResolver); - javaAnnotationResolver.setClassResolver(javaClassResolver); - - javaAnnotationArgumentResolver.setAnnotationResolver(javaAnnotationResolver); - javaAnnotationArgumentResolver.setClassResolver(javaClassResolver); - deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer); deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter); deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver); @@ -165,6 +171,7 @@ public class InjectorForJavaDescriptorResolver { javaTypeTransformer.setClassResolver(javaClassResolver); + javaValueParameterResolver.setAnnotationResolver(javaAnnotationResolver); javaValueParameterResolver.setTypeTransformer(javaTypeTransformer); javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 504b7e54307..e0559fcc0f4 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -36,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache; import org.jetbrains.jet.lang.resolve.java.resolver.FakeOverrideVisibilityResolverImpl; import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter; import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker; +import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver; import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.DeclarationResolver; @@ -94,6 +95,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final FakeOverrideVisibilityResolverImpl fakeOverrideVisibilityResolver; private final TraceBasedErrorReporter traceBasedErrorReporter; private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker; + private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver; private final NamespaceFactoryImpl namespaceFactory; private final VirtualFileFinder virtualFileFinder; private final DeclarationResolver declarationResolver; @@ -153,6 +155,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.fakeOverrideVisibilityResolver = new FakeOverrideVisibilityResolverImpl(); this.traceBasedErrorReporter = new TraceBasedErrorReporter(); this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker(); + this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver(); this.namespaceFactory = new NamespaceFactoryImpl(); this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class); this.declarationResolver = new DeclarationResolver(); @@ -228,6 +231,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaClassFinder.setPsiClassFinder(psiClassFinder); + traceBasedExternalSignatureResolver.setAnnotationResolver(javaAnnotationResolver); traceBasedExternalSignatureResolver.setTrace(bindingTrace); traceBasedJavaResolverCache.setTrace(bindingTrace); @@ -236,6 +240,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly traceBasedErrorReporter.setTrace(bindingTrace); + psiBasedMethodSignatureChecker.setAnnotationResolver(javaAnnotationResolver); psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver); this.namespaceFactory.setModuleDescriptor(moduleDescriptor); @@ -320,6 +325,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaAnnotationResolver.setArgumentResolver(javaAnnotationArgumentResolver); javaAnnotationResolver.setClassResolver(javaClassResolver); + javaAnnotationResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); javaAnnotationArgumentResolver.setAnnotationResolver(javaAnnotationResolver); javaAnnotationArgumentResolver.setClassResolver(javaClassResolver); @@ -352,6 +358,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaTypeTransformer.setClassResolver(javaClassResolver); + javaValueParameterResolver.setAnnotationResolver(javaAnnotationResolver); javaValueParameterResolver.setTypeTransformer(javaTypeTransformer); javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java index c7f26a9824b..d02e3da27b5 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; import org.jetbrains.jet.lang.psi.JetProperty; import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.structure.JavaField; import org.jetbrains.jet.lang.types.JetType; @@ -31,8 +32,13 @@ import java.util.HashMap; public class AlternativeFieldSignatureData extends ElementAlternativeSignatureData { private JetType altReturnType; - public AlternativeFieldSignatureData(@NotNull JavaField field, @NotNull JetType originalReturnType, boolean isVar) { - String signature = SignaturesUtil.getKotlinSignature(field); + public AlternativeFieldSignatureData( + @NotNull JavaAnnotationResolver annotationResolver, + @NotNull JavaField field, + @NotNull JetType originalReturnType, + boolean isVar + ) { + String signature = SignaturesUtil.getKotlinSignature(annotationResolver, field); if (signature == null) { setAnnotated(false); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java index 3d020c86406..a82fa5fb6e6 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java @@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; @@ -52,6 +53,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD private Map originalToAltTypeParameters; public AlternativeMethodSignatureData( + @NotNull JavaAnnotationResolver annotationResolver, @NotNull JavaMethod method, @Nullable JetType receiverType, @NotNull List valueParameters, @@ -59,7 +61,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD @NotNull List methodTypeParameters, boolean hasSuperMethods ) { - String signature = SignaturesUtil.getKotlinSignature(method); + String signature = SignaturesUtil.getKotlinSignature(annotationResolver, method); if (signature == null) { setAnnotated(false); 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 a6b23f03300..30f905c5aac 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 @@ -71,8 +71,8 @@ public class SignaturesUtil { } @Nullable - public static String getKotlinSignature(@NotNull JavaMember member) { - JavaAnnotation annotation = JavaAnnotationResolver.findAnnotationWithExternal(member, JvmAnnotationNames.KOTLIN_SIGNATURE); + public static String getKotlinSignature(@NotNull JavaAnnotationResolver annotationResolver, @NotNull JavaMember member) { + JavaAnnotation annotation = annotationResolver.findAnnotationWithExternal(member, JvmAnnotationNames.KOTLIN_SIGNATURE); if (annotation != null) { JavaAnnotationArgument argument = annotation.findArgument(JvmAnnotationNames.KOTLIN_SIGNATURE_VALUE_FIELD_NAME); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ExternalAnnotationResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ExternalAnnotationResolver.java new file mode 100644 index 00000000000..77006e5cdb2 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ExternalAnnotationResolver.java @@ -0,0 +1,33 @@ +/* + * Copyright 2010-2013 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.jet.lang.resolve.java.resolver; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotation; +import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotationOwner; +import org.jetbrains.jet.lang.resolve.name.FqName; + +import java.util.Collection; + +public interface ExternalAnnotationResolver { + @Nullable + JavaAnnotation findExternalAnnotation(@NotNull JavaAnnotationOwner owner, @NotNull FqName fqName); + + @NotNull + Collection findExternalAnnotations(@NotNull JavaAnnotationOwner owner); +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java index 4e5c0d30034..aa85e8f6aa0 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java @@ -16,10 +16,7 @@ package org.jetbrains.jet.lang.resolve.java.resolver; -import com.intellij.codeInsight.ExternalAnnotationsManager; -import com.intellij.psi.PsiAnnotation; -import com.intellij.psi.PsiModifierList; -import com.intellij.psi.PsiModifierListOwner; +import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; @@ -38,7 +35,6 @@ import org.jetbrains.jet.lang.resolve.name.Name; import javax.inject.Inject; import java.util.ArrayList; -import java.util.Collection; import java.util.List; import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; @@ -48,6 +44,7 @@ public final class JavaAnnotationResolver { private JavaClassResolver classResolver; private JavaAnnotationArgumentResolver argumentResolver; + private ExternalAnnotationResolver externalAnnotationResolver; public JavaAnnotationResolver() { } @@ -62,16 +59,23 @@ public final class JavaAnnotationResolver { this.argumentResolver = argumentResolver; } + @Inject + public void setExternalAnnotationResolver(ExternalAnnotationResolver externalAnnotationResolver) { + this.externalAnnotationResolver = externalAnnotationResolver; + } + @NotNull public List resolveAnnotations(@NotNull JavaAnnotationOwner owner, @NotNull PostponedTasks tasks) { - Collection annotations = getAnnotationsWithExternal(owner); - List result = new ArrayList(annotations.size()); - for (JavaAnnotation javaAnnotation : annotations) { - AnnotationDescriptor annotation = resolveAnnotation(javaAnnotation, tasks); - if (annotation != null) { - result.add(annotation); - } + List result = new ArrayList(); + + for (JavaAnnotation annotation : owner.getAnnotations()) { + ContainerUtil.addIfNotNull(result, resolveAnnotation(annotation, tasks)); } + + for (JavaAnnotation annotation : externalAnnotationResolver.findExternalAnnotations(owner)) { + ContainerUtil.addIfNotNull(result, resolveAnnotation(annotation, tasks)); + } + return result; } @@ -133,55 +137,25 @@ public final class JavaAnnotationResolver { return annotation; } - @NotNull - private static Collection getAnnotationsWithExternal(@NotNull JavaAnnotationOwner owner) { - List result = new ArrayList(); - - result.addAll(owner.getAnnotations()); - - PsiAnnotation[] externalAnnotations = - ExternalAnnotationsManager.getInstance(owner.getPsi().getProject()).findExternalAnnotations(owner.getPsi()); - if (externalAnnotations != null) { - for (PsiAnnotation annotation : externalAnnotations) { - result.add(new JavaAnnotation(annotation)); - } - } - - return result; - } - @Nullable - public static JavaAnnotation findAnnotationWithExternal(@NotNull JavaAnnotationOwner owner, @NotNull JvmClassName name) { + public JavaAnnotation findAnnotationWithExternal(@NotNull JavaAnnotationOwner owner, @NotNull JvmClassName name) { JavaAnnotation annotation = owner.findAnnotation(name.getFqName()); if (annotation != null) { return annotation; } - PsiAnnotation externalAnnotation = findExternalAnnotation(owner.getPsi(), name); - return externalAnnotation == null ? null : new JavaAnnotation(externalAnnotation); + return externalAnnotationResolver.findExternalAnnotation(owner, name.getFqName()); } - public static boolean hasNotNullAnnotation(@NotNull JavaAnnotationOwner owner) { + public boolean hasNotNullAnnotation(@NotNull JavaAnnotationOwner owner) { return findAnnotationWithExternal(owner, JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION) != null; } - public static boolean hasMutableAnnotation(@NotNull JavaAnnotationOwner owner) { + public boolean hasMutableAnnotation(@NotNull JavaAnnotationOwner owner) { return findAnnotationWithExternal(owner, JvmAnnotationNames.JETBRAINS_MUTABLE_ANNOTATION) != null; } - public static boolean hasReadonlyAnnotation(@NotNull JavaAnnotationOwner owner) { + public boolean hasReadonlyAnnotation(@NotNull JavaAnnotationOwner owner) { return findAnnotationWithExternal(owner, JvmAnnotationNames.JETBRAINS_READONLY_ANNOTATION) != null; } - - - @Nullable - public static PsiAnnotation findOwnAnnotation(@NotNull PsiModifierListOwner owner, @NotNull JvmClassName name) { - PsiModifierList list = owner.getModifierList(); - return list == null ? null : list.findAnnotation(name.getFqName().asString()); - } - - @Nullable - public static PsiAnnotation findExternalAnnotation(@NotNull PsiModifierListOwner owner, @NotNull JvmClassName name) { - return ExternalAnnotationsManager.getInstance(owner.getProject()).findExternalAnnotation(owner, name.getFqName().asString()); - } } \ No newline at end of file diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index 4e80750e9f6..9166f9875fd 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -303,12 +303,12 @@ public final class JavaFunctionResolver { @NotNull JavaMethod method, @NotNull TypeVariableResolver typeVariableResolver ) { - TypeUsage typeUsage = JavaAnnotationResolver.hasReadonlyAnnotation(method) && !JavaAnnotationResolver.hasMutableAnnotation(method) + TypeUsage typeUsage = annotationResolver.hasReadonlyAnnotation(method) && !annotationResolver.hasMutableAnnotation(method) ? TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT : TypeUsage.MEMBER_SIGNATURE_COVARIANT; JetType transformedType = typeTransformer.transformToType(returnType, typeUsage, typeVariableResolver); - if (JavaAnnotationResolver.hasNotNullAnnotation(method)) { + if (annotationResolver.hasNotNullAnnotation(method)) { return TypeUtils.makeNotNullable(transformedType); } else { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java index 877b478a315..20915a85eeb 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java @@ -167,7 +167,7 @@ public final class JavaPropertyResolver { private JetType getPropertyType(@NotNull JavaField field, @NotNull TypeVariableResolver typeVariableResolver) { JetType propertyType = typeTransformer.transformToType(field.getType(), typeVariableResolver); - if (JavaAnnotationResolver.hasNotNullAnnotation(field) || isStaticFinalField(field) /* TODO: WTF? */) { + if (annotationResolver.hasNotNullAnnotation(field) || isStaticFinalField(field) /* TODO: WTF? */) { return TypeUtils.makeNotNullable(propertyType); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java index c2fb6059474..9a09011d349 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java @@ -38,8 +38,19 @@ import java.util.Collections; import java.util.List; public final class JavaValueParameterResolver { + private JavaAnnotationResolver annotationResolver; private JavaTypeTransformer typeTransformer; + @Inject + public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) { + this.annotationResolver = annotationResolver; + } + + @Inject + public void setTypeTransformer(JavaTypeTransformer typeTransformer) { + this.typeTransformer = typeTransformer; + } + @NotNull private ValueParameterDescriptor resolveValueParameter( @NotNull DeclarationDescriptor containingDeclaration, @@ -47,7 +58,7 @@ public final class JavaValueParameterResolver { @NotNull JavaValueParameter parameter, @NotNull TypeVariableResolver typeVariableResolver ) { - TypeUsage typeUsage = JavaAnnotationResolver.hasMutableAnnotation(parameter) + TypeUsage typeUsage = annotationResolver.hasMutableAnnotation(parameter) ? TypeUsage.MEMBER_SIGNATURE_COVARIANT : TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT; @@ -65,7 +76,7 @@ public final class JavaValueParameterResolver { } else { JetType transformedType = typeTransformer.transformToType(parameterType, typeUsage, typeVariableResolver); - if (transformedType.isNullable() && JavaAnnotationResolver.hasNotNullAnnotation(parameter)) { + if (transformedType.isNullable() && annotationResolver.hasNotNullAnnotation(parameter)) { transformedType = TypeUtils.makeNotNullable(transformedType); } @@ -84,11 +95,6 @@ public final class JavaValueParameterResolver { ); } - @Inject - public void setTypeTransformer(JavaTypeTransformer typeTransformer) { - this.typeTransformer = typeTransformer; - } - @NotNull private static Name getParameterName(int number, @NotNull JavaValueParameter parameter) { Name psiParameterName = parameter.getName(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedExternalAnnotationResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedExternalAnnotationResolver.java new file mode 100644 index 00000000000..af362c876d4 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedExternalAnnotationResolver.java @@ -0,0 +1,62 @@ +/* + * Copyright 2010-2013 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.jet.lang.resolve.java.resolver; + +import com.intellij.codeInsight.ExternalAnnotationsManager; +import com.intellij.psi.PsiAnnotation; +import com.intellij.psi.PsiModifierList; +import com.intellij.psi.PsiModifierListOwner; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.resolve.java.JvmClassName; +import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotation; +import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotationOwner; +import org.jetbrains.jet.lang.resolve.java.structure.JavaElementCollectionFromPsiArrayUtil; +import org.jetbrains.jet.lang.resolve.name.FqName; + +import java.util.Collection; +import java.util.Collections; + +public class PsiBasedExternalAnnotationResolver implements ExternalAnnotationResolver { + @Nullable + @Override + public JavaAnnotation findExternalAnnotation(@NotNull JavaAnnotationOwner owner, @NotNull FqName fqName) { + PsiAnnotation psiAnnotation = findExternalAnnotation(owner.getPsi(), fqName); + return psiAnnotation == null ? null : new JavaAnnotation(psiAnnotation); + } + + @NotNull + @Override + public Collection findExternalAnnotations(@NotNull JavaAnnotationOwner owner) { + PsiModifierListOwner psiOwner = owner.getPsi(); + PsiAnnotation[] annotations = ExternalAnnotationsManager.getInstance(psiOwner.getProject()).findExternalAnnotations(psiOwner); + return annotations == null + ? Collections.emptyList() + : JavaElementCollectionFromPsiArrayUtil.annotations(annotations); + } + + @Nullable + public static PsiAnnotation findExternalAnnotation(@NotNull PsiModifierListOwner owner, @NotNull FqName fqName) { + return ExternalAnnotationsManager.getInstance(owner.getProject()).findExternalAnnotation(owner, fqName.asString()); + } + + @Nullable + public static PsiAnnotation findOwnAnnotation(@NotNull PsiModifierListOwner owner, @NotNull JvmClassName name) { + PsiModifierList list = owner.getModifierList(); + return list == null ? null : list.findAnnotation(name.getFqName().asString()); + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java index fa2cc14d3a5..0614557a17b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java @@ -45,14 +45,20 @@ import static org.jetbrains.jet.lang.resolve.OverridingUtil.isReturnTypeOkForOve public class PsiBasedMethodSignatureChecker implements MethodSignatureChecker { private static final Logger LOG = Logger.getInstance(PsiBasedMethodSignatureChecker.class); + private JavaAnnotationResolver annotationResolver; private ExternalSignatureResolver externalSignatureResolver; + @Inject + public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) { + this.annotationResolver = annotationResolver; + } + @Inject public void setExternalSignatureResolver(ExternalSignatureResolver externalSignatureResolver) { this.externalSignatureResolver = externalSignatureResolver; } - private static void checkFunctionOverridesCorrectly( + private void checkFunctionOverridesCorrectly( @NotNull JavaMethod method, @NotNull FunctionDescriptor function, @NotNull FunctionDescriptor superFunction @@ -81,7 +87,7 @@ public class PsiBasedMethodSignatureChecker implements MethodSignatureChecker { + "sub function = " + function + "\n" + "sub class = " + function.getContainingDeclaration() + "\n" + "sub method = " + JavaSignatureFormatter.getExternalName(method) + "\n" - + "@KotlinSignature = " + SignaturesUtil.getKotlinSignature(method)); + + "@KotlinSignature = " + SignaturesUtil.getKotlinSignature(annotationResolver, method)); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedExternalSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedExternalSignatureResolver.java index eb82102a7fc..29359bb4a94 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedExternalSignatureResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedExternalSignatureResolver.java @@ -18,7 +18,10 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.java.JavaBindingContext; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeFieldSignatureData; @@ -34,12 +37,18 @@ import java.util.List; public class TraceBasedExternalSignatureResolver implements ExternalSignatureResolver { private BindingTrace trace; + private JavaAnnotationResolver annotationResolver; @Inject public void setTrace(BindingTrace trace) { this.trace = trace; } + @Inject + public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) { + this.annotationResolver = annotationResolver; + } + @Override @NotNull public PropagatedMethodSignature resolvePropagatedSignature( @@ -68,7 +77,8 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes @NotNull List typeParameters ) { AlternativeMethodSignatureData data = - new AlternativeMethodSignatureData(method, receiverType, valueParameters, returnType, typeParameters, hasSuperMethods); + new AlternativeMethodSignatureData(annotationResolver, method, receiverType, valueParameters, returnType, typeParameters, + hasSuperMethods); if (data.isAnnotated() && !data.hasErrors()) { return new AlternativeMethodSignature(data.getReturnType(), receiverType, data.getValueParameters(), data.getTypeParameters(), @@ -86,7 +96,7 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes @NotNull JetType returnType, boolean isVar ) { - AlternativeFieldSignatureData data = new AlternativeFieldSignatureData(field, returnType, isVar); + AlternativeFieldSignatureData data = new AlternativeFieldSignatureData(annotationResolver, field, returnType, isVar); if (data.isAnnotated() && !data.hasErrors()) { return new AlternativeFieldSignature(data.getReturnType(), null); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java index 6fb52441ce8..f7685f55003 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java @@ -25,7 +25,7 @@ import java.util.Collection; import java.util.Collections; import java.util.List; -/* package */ class JavaElementCollectionFromPsiArrayUtil { +public class JavaElementCollectionFromPsiArrayUtil { private JavaElementCollectionFromPsiArrayUtil() { } diff --git a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index 9463ff44982..f383a045209 100644 --- a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java @@ -111,6 +111,7 @@ public class GenerateInjectors { generator.addField(FakeOverrideVisibilityResolverImpl.class); generator.addField(TraceBasedErrorReporter.class); generator.addField(PsiBasedMethodSignatureChecker.class); + generator.addField(PsiBasedExternalAnnotationResolver.class); generator.addPublicField(NamespaceFactoryImpl.class); generator.addField(false, VirtualFileFinder.class, "virtualFileFinder", new GivenExpression( @@ -133,6 +134,7 @@ public class GenerateInjectors { generator.addField(FakeOverrideVisibilityResolverImpl.class); generator.addField(TraceBasedErrorReporter.class); generator.addField(PsiBasedMethodSignatureChecker.class); + generator.addField(PsiBasedExternalAnnotationResolver.class); generator.addPublicField(JavaDescriptorResolver.class); generator.addPublicField(PsiClassFinderImpl.class); generator.addField(false, VirtualFileFinder.class, "virtualFileFinder", diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java index 94b0e807142..50d6bcbdc03 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java @@ -26,7 +26,7 @@ import com.intellij.psi.impl.compiled.ClsElementImpl; import com.intellij.psi.impl.source.SourceTreeToPsiMap; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver; import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.KOTLIN_SIGNATURE; @@ -81,9 +81,10 @@ class KotlinSignatureUtil { static PsiAnnotation findKotlinSignatureAnnotation(@NotNull PsiElement element) { if (!(element instanceof PsiModifierListOwner)) return null; PsiModifierListOwner annotationOwner = getAnnotationOwner(element); - PsiAnnotation ownAnnotation = JavaAnnotationResolver.findOwnAnnotation(annotationOwner, KOTLIN_SIGNATURE); - PsiAnnotation annotation = ownAnnotation != null ? ownAnnotation - : JavaAnnotationResolver.findExternalAnnotation(annotationOwner, KOTLIN_SIGNATURE); + PsiAnnotation ownAnnotation = PsiBasedExternalAnnotationResolver.findOwnAnnotation(annotationOwner, KOTLIN_SIGNATURE); + PsiAnnotation annotation = ownAnnotation != null + ? ownAnnotation + : PsiBasedExternalAnnotationResolver.findExternalAnnotation(annotationOwner, KOTLIN_SIGNATURE.getFqName()); if (annotation == null) return null; if (annotation.getParameterList().getAttributes().length == 0) return null; return annotation;