From 69295290eb800728393c8e3080fee26ff163a1dc Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Fri, 5 Jul 2013 14:09:45 +0400 Subject: [PATCH] Remove big chunk of code related to using old annotations --- .../di/InjectorForJavaDescriptorResolver.java | 23 +-- .../di/InjectorForJavaSemanticServices.java | 23 +-- .../di/InjectorForTopDownAnalyzerForJvm.java | 23 +-- .../resolve/java/DescriptorResolverUtils.java | 36 +--- .../lang/resolve/java/PackageClassUtils.java | 4 +- .../PropagationHeuristics.java | 21 +-- .../java/kt/JetClassObjectAnnotation.java | 44 ----- .../java/kt/JetConstructorAnnotation.java | 54 ------ .../resolve/java/kt/JetMethodAnnotation.java | 75 -------- .../java/kt/JetPackageClassAnnotation.java | 42 ----- .../java/kt/JetTypeParameterAnnotation.java | 46 ----- .../java/kt/JetValueParameterAnnotation.java | 8 +- .../java/kt/PsiAnnotationWithFlags.java | 24 --- .../ClassPsiDeclarationProviderImpl.java | 6 +- ...KotlinNamespacePsiDeclarationProvider.java | 58 ------ .../resolve/java/provider/MembersCache.java | 108 ++--------- .../PsiDeclarationProviderFactory.java | 6 - .../resolver/JavaClassObjectResolver.java | 168 ------------------ .../java/resolver/JavaClassResolver.java | 90 +++++++--- .../resolver/JavaConstructorResolver.java | 21 +-- .../java/resolver/JavaFunctionResolver.java | 74 ++++---- .../java/resolver/JavaInnerClassResolver.java | 9 - .../java/resolver/JavaNamespaceResolver.java | 3 +- .../java/resolver/JavaPropertyResolver.java | 32 ++-- .../java/resolver/JavaSignatureResolver.java | 126 +++++++------ .../java/resolver/JavaSupertypeResolver.java | 63 +------ .../resolver/JavaValueParameterResolver.java | 66 +++---- .../scope/JavaScopeForKotlinNamespace.java | 56 ------ .../java/wrapper/PropertyPsiDataElement.java | 13 -- .../resolve/java/wrapper/PsiClassWrapper.java | 21 --- .../java/wrapper/PsiMethodWrapper.java | 28 +-- .../java/wrapper/PsiParameterWrapper.java | 20 --- 32 files changed, 255 insertions(+), 1136 deletions(-) delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassObjectAnnotation.java delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetConstructorAnnotation.java delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetMethodAnnotation.java delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetTypeParameterAnnotation.java delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/KotlinNamespacePsiDeclarationProvider.java delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java 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 2d850541ad2..1fb2c9328c9 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -28,8 +28,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; 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.JavaCompileTimeConstResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; @@ -37,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolv import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver; @@ -58,8 +57,6 @@ public class InjectorForJavaDescriptorResolver { private final JavaClassResolver javaClassResolver; private final JavaAnnotationResolver javaAnnotationResolver; private final JavaCompileTimeConstResolver javaCompileTimeConstResolver; - private final JavaClassObjectResolver javaClassObjectResolver; - private final JavaSupertypeResolver javaSupertypeResolver; private final JavaFunctionResolver javaFunctionResolver; private final JavaValueParameterResolver javaValueParameterResolver; private final JavaSignatureResolver javaSignatureResolver; @@ -67,6 +64,7 @@ public class InjectorForJavaDescriptorResolver { private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final ErrorReporter errorReporter; private final JavaNamespaceResolver javaNamespaceResolver; + private final JavaSupertypeResolver javaSupertypeResolver; private final JavaConstructorResolver javaConstructorResolver; private final JavaInnerClassResolver javaInnerClassResolver; private final JavaPropertyResolver javaPropertyResolver; @@ -88,8 +86,6 @@ public class InjectorForJavaDescriptorResolver { this.javaClassResolver = new JavaClassResolver(); this.javaAnnotationResolver = new JavaAnnotationResolver(); this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver(); - this.javaClassObjectResolver = new JavaClassObjectResolver(); - this.javaSupertypeResolver = new JavaSupertypeResolver(); this.javaFunctionResolver = new JavaFunctionResolver(); this.javaValueParameterResolver = new JavaValueParameterResolver(); this.javaSignatureResolver = new JavaSignatureResolver(); @@ -97,6 +93,7 @@ public class InjectorForJavaDescriptorResolver { this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); this.errorReporter = new ErrorReporter(); this.javaNamespaceResolver = new JavaNamespaceResolver(); + this.javaSupertypeResolver = new JavaSupertypeResolver(); this.javaConstructorResolver = new JavaConstructorResolver(); this.javaInnerClassResolver = new JavaInnerClassResolver(); this.javaPropertyResolver = new JavaPropertyResolver(); @@ -122,7 +119,6 @@ public class InjectorForJavaDescriptorResolver { javaTypeTransformer.setResolver(javaDescriptorResolver); javaClassResolver.setAnnotationResolver(javaAnnotationResolver); - javaClassResolver.setClassObjectResolver(javaClassObjectResolver); javaClassResolver.setFunctionResolver(javaFunctionResolver); javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); @@ -138,15 +134,6 @@ public class InjectorForJavaDescriptorResolver { javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver); javaCompileTimeConstResolver.setClassResolver(javaClassResolver); - javaClassObjectResolver.setSemanticServices(javaSemanticServices); - javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver); - javaClassObjectResolver.setTrace(bindingTrace); - - javaSupertypeResolver.setClassResolver(javaClassResolver); - javaSupertypeResolver.setSemanticServices(javaSemanticServices); - javaSupertypeResolver.setTrace(bindingTrace); - javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); - javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); javaFunctionResolver.setParameterResolver(javaValueParameterResolver); javaFunctionResolver.setSignatureResolver(javaSignatureResolver); @@ -172,6 +159,10 @@ public class InjectorForJavaDescriptorResolver { javaNamespaceResolver.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setTrace(bindingTrace); + javaSupertypeResolver.setClassResolver(javaClassResolver); + javaSupertypeResolver.setTrace(bindingTrace); + javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); + javaConstructorResolver.setTrace(bindingTrace); javaConstructorResolver.setTypeTransformer(javaTypeTransformer); javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java index 9ffac62baee..c380c2c422c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java @@ -28,8 +28,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; 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.JavaCompileTimeConstResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; @@ -37,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolv import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver; @@ -58,8 +57,6 @@ public class InjectorForJavaSemanticServices { private final JavaClassResolver javaClassResolver; private final JavaAnnotationResolver javaAnnotationResolver; private final JavaCompileTimeConstResolver javaCompileTimeConstResolver; - private final JavaClassObjectResolver javaClassObjectResolver; - private final JavaSupertypeResolver javaSupertypeResolver; private final JavaFunctionResolver javaFunctionResolver; private final JavaValueParameterResolver javaValueParameterResolver; private final JavaSignatureResolver javaSignatureResolver; @@ -67,6 +64,7 @@ public class InjectorForJavaSemanticServices { private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final ErrorReporter errorReporter; private final JavaNamespaceResolver javaNamespaceResolver; + private final JavaSupertypeResolver javaSupertypeResolver; private final JavaConstructorResolver javaConstructorResolver; private final JavaInnerClassResolver javaInnerClassResolver; private final JavaPropertyResolver javaPropertyResolver; @@ -86,8 +84,6 @@ public class InjectorForJavaSemanticServices { this.javaClassResolver = new JavaClassResolver(); this.javaAnnotationResolver = new JavaAnnotationResolver(); this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver(); - this.javaClassObjectResolver = new JavaClassObjectResolver(); - this.javaSupertypeResolver = new JavaSupertypeResolver(); this.javaFunctionResolver = new JavaFunctionResolver(); this.javaValueParameterResolver = new JavaValueParameterResolver(); this.javaSignatureResolver = new JavaSignatureResolver(); @@ -95,6 +91,7 @@ public class InjectorForJavaSemanticServices { this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); this.errorReporter = new ErrorReporter(); this.javaNamespaceResolver = new JavaNamespaceResolver(); + this.javaSupertypeResolver = new JavaSupertypeResolver(); this.javaConstructorResolver = new JavaConstructorResolver(); this.javaInnerClassResolver = new JavaInnerClassResolver(); this.javaPropertyResolver = new JavaPropertyResolver(); @@ -122,7 +119,6 @@ public class InjectorForJavaSemanticServices { javaTypeTransformer.setResolver(javaDescriptorResolver); javaClassResolver.setAnnotationResolver(javaAnnotationResolver); - javaClassResolver.setClassObjectResolver(javaClassObjectResolver); javaClassResolver.setFunctionResolver(javaFunctionResolver); javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); @@ -138,15 +134,6 @@ public class InjectorForJavaSemanticServices { javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver); javaCompileTimeConstResolver.setClassResolver(javaClassResolver); - javaClassObjectResolver.setSemanticServices(javaSemanticServices); - javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver); - javaClassObjectResolver.setTrace(bindingTrace); - - javaSupertypeResolver.setClassResolver(javaClassResolver); - javaSupertypeResolver.setSemanticServices(javaSemanticServices); - javaSupertypeResolver.setTrace(bindingTrace); - javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); - javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); javaFunctionResolver.setParameterResolver(javaValueParameterResolver); javaFunctionResolver.setSignatureResolver(javaSignatureResolver); @@ -172,6 +159,10 @@ public class InjectorForJavaSemanticServices { javaNamespaceResolver.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setTrace(bindingTrace); + javaSupertypeResolver.setClassResolver(javaClassResolver); + javaSupertypeResolver.setTrace(bindingTrace); + javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); + javaConstructorResolver.setTrace(bindingTrace); javaConstructorResolver.setTypeTransformer(javaTypeTransformer); javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); 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 41f97159f72..73b64e7d2dd 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -53,8 +53,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; 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.JavaCompileTimeConstResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; @@ -62,6 +60,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolv import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver; @@ -108,8 +107,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final JavaClassResolver javaClassResolver; private final JavaAnnotationResolver javaAnnotationResolver; private final JavaCompileTimeConstResolver javaCompileTimeConstResolver; - private final JavaClassObjectResolver javaClassObjectResolver; - private final JavaSupertypeResolver javaSupertypeResolver; private final JavaFunctionResolver javaFunctionResolver; private final JavaValueParameterResolver javaValueParameterResolver; private final JavaSignatureResolver javaSignatureResolver; @@ -117,6 +114,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final ErrorReporter errorReporter; private final JavaNamespaceResolver javaNamespaceResolver; + private final JavaSupertypeResolver javaSupertypeResolver; private final JavaConstructorResolver javaConstructorResolver; private final JavaInnerClassResolver javaInnerClassResolver; private final JavaPropertyResolver javaPropertyResolver; @@ -164,8 +162,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.javaClassResolver = new JavaClassResolver(); this.javaAnnotationResolver = new JavaAnnotationResolver(); this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver(); - this.javaClassObjectResolver = new JavaClassObjectResolver(); - this.javaSupertypeResolver = new JavaSupertypeResolver(); this.javaFunctionResolver = new JavaFunctionResolver(); this.javaValueParameterResolver = new JavaValueParameterResolver(); this.javaSignatureResolver = new JavaSignatureResolver(); @@ -173,6 +169,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); this.errorReporter = new ErrorReporter(); this.javaNamespaceResolver = new JavaNamespaceResolver(); + this.javaSupertypeResolver = new JavaSupertypeResolver(); this.javaConstructorResolver = new JavaConstructorResolver(); this.javaInnerClassResolver = new JavaInnerClassResolver(); this.javaPropertyResolver = new JavaPropertyResolver(); @@ -300,7 +297,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaTypeTransformer.setResolver(javaDescriptorResolver); javaClassResolver.setAnnotationResolver(javaAnnotationResolver); - javaClassResolver.setClassObjectResolver(javaClassObjectResolver); javaClassResolver.setFunctionResolver(javaFunctionResolver); javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); @@ -316,15 +312,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver); javaCompileTimeConstResolver.setClassResolver(javaClassResolver); - javaClassObjectResolver.setSemanticServices(javaSemanticServices); - javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver); - javaClassObjectResolver.setTrace(bindingTrace); - - javaSupertypeResolver.setClassResolver(javaClassResolver); - javaSupertypeResolver.setSemanticServices(javaSemanticServices); - javaSupertypeResolver.setTrace(bindingTrace); - javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); - javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); javaFunctionResolver.setParameterResolver(javaValueParameterResolver); javaFunctionResolver.setSignatureResolver(javaSignatureResolver); @@ -350,6 +337,10 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaNamespaceResolver.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setTrace(bindingTrace); + javaSupertypeResolver.setClassResolver(javaClassResolver); + javaSupertypeResolver.setTrace(bindingTrace); + javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); + javaConstructorResolver.setTrace(bindingTrace); javaConstructorResolver.setTypeTransformer(javaTypeTransformer); javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java index e2513f73d8b..f1d518e4fe7 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java @@ -23,9 +23,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.constants.StringValue; -import org.jetbrains.jet.lang.resolve.java.kt.PsiAnnotationWithFlags; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; @@ -63,36 +60,9 @@ public final class DescriptorResolverUtils { return Collections.emptyList(); } - public static Modality resolveModality(PsiMemberWrapper memberWrapper, boolean isFinal) { - if (memberWrapper instanceof PsiMethodWrapper) { - PsiMethodWrapper method = (PsiMethodWrapper) memberWrapper; - if (method.getJetMethodAnnotation().hasForceOpenFlag()) { - return Modality.OPEN; - } - if (method.getJetMethodAnnotation().hasForceFinalFlag()) { - return Modality.FINAL; - } - } - - return Modality.convertFromFlags(memberWrapper.isAbstract(), !isFinal); - } - public static Visibility resolveVisibility( - @NotNull PsiModifierListOwner modifierListOwner, - @Nullable PsiAnnotationWithFlags annotation + @NotNull PsiModifierListOwner modifierListOwner ) { - if (annotation != null) { - if (annotation.hasPrivateFlag()) { - return Visibilities.PRIVATE; - } - else if (annotation.hasInternalFlag()) { - return Visibilities.INTERNAL; - } - else if (annotation.hasProtectedFlag()) { - return Visibilities.PROTECTED; - } - } - if (modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC)) { return Visibilities.PUBLIC; } @@ -159,7 +129,7 @@ public final class DescriptorResolverUtils { /** * @return true if {@code member} is a static member of enum class, which is to be put into its class object (and not into the - * corresponding package). This applies to enum entries, values() and valueOf(String) methods + * corresponding package). This applies to enum entries, values() and valueOf(String) methods */ public static boolean shouldBeInEnumClassObject(@NotNull PsiMember member) { PsiClass psiClass = member.getContainingClass(); @@ -169,7 +139,7 @@ public final class DescriptorResolverUtils { if (!(member instanceof PsiMethod)) return false; String signature = PsiFormatUtil.formatMethod((PsiMethod) member, - PsiSubstitutor.EMPTY, SHOW_NAME | SHOW_PARAMETERS, SHOW_TYPE | SHOW_FQ_CLASS_NAMES); + PsiSubstitutor.EMPTY, SHOW_NAME | SHOW_PARAMETERS, SHOW_TYPE | SHOW_FQ_CLASS_NAMES); return "values()".equals(signature) || "valueOf(java.lang.String)".equals(signature); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PackageClassUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PackageClassUtils.java index a268623bc4b..bd7b764d03e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PackageClassUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PackageClassUtils.java @@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.java; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiClass; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.java.kt.JetPackageClassAnnotation; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -40,7 +39,8 @@ public class PackageClassUtils { } public static boolean isPackageClass(@NotNull PsiClass psiClass) { - return JetPackageClassAnnotation.get(psiClass).isDefined(); + //TODO: read kotlin info + return psiClass.getName().endsWith("Package"); } public static boolean isPackageClass(@NotNull FqName fqName) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java index 941175e951c..6a5db6423b7 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java @@ -25,11 +25,8 @@ import com.intellij.psi.impl.PsiSubstitutorImpl; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetTypeImpl; @@ -71,7 +68,7 @@ class PropagationHeuristics { JetType elementType = type.getArguments().get(0).getType(); if (JetTypeChecker.INSTANCE.isSubtypeOf(elementType, elementTypeInSuper) - && !JetTypeChecker.INSTANCE.equalTypes(elementType, elementTypeInSuper)) { + && !JetTypeChecker.INSTANCE.equalTypes(elementType, elementTypeInSuper)) { JetTypeImpl betterTypeInSuper = new JetTypeImpl( arrayTypeFromSuper.getAnnotations(), arrayTypeFromSuper.getConstructor(), @@ -127,21 +124,7 @@ class PropagationHeuristics { @NotNull static List getSuperMethods(@NotNull PsiMethod method) { - List superMethods = Lists.newArrayList(); - for (PsiMethod superMethod : new SuperMethodCollector(method).collect()) { - CallableMemberDescriptor.Kind kindFromFlags = - DescriptorKindUtils.flagsToKind(new PsiMethodWrapper(superMethod).getJetMethodAnnotation().kind()); - if (kindFromFlags == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) { - // This is for the case when a Kotlin class inherits a non-abstract method from a trait: - // from Kotlin's point of view it is fake override, from Java's it is normal override. - // We replace this "fake override" method with original method from the trait. - superMethods.addAll(getSuperMethods(superMethod)); - } - else { - superMethods.add(superMethod); - } - } - return superMethods; + return new SuperMethodCollector(method).collect(); } private PropagationHeuristics() { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassObjectAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassObjectAnnotation.java deleted file mode 100644 index c4a118d957d..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassObjectAnnotation.java +++ /dev/null @@ -1,44 +0,0 @@ -/* - * 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.kt; - -import com.intellij.psi.PsiAnnotation; -import com.intellij.psi.PsiClass; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; - -public class JetClassObjectAnnotation extends PsiAnnotationWithAbiVersion { - - private static final JetClassObjectAnnotation NULL_ANNOTATION = new JetClassObjectAnnotation(null); - - static { - NULL_ANNOTATION.checkInitialized(); - } - - private JetClassObjectAnnotation(@Nullable PsiAnnotation psiAnnotation) { - super(psiAnnotation); - } - - @NotNull - public static JetClassObjectAnnotation get(@NotNull PsiClass psiClass) { - PsiAnnotation annotation = - JavaAnnotationResolver.findOwnAnnotation(psiClass, JvmStdlibNames.JET_CLASS_OBJECT.getFqName().asString()); - return annotation != null ? new JetClassObjectAnnotation(annotation) : NULL_ANNOTATION; - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetConstructorAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetConstructorAnnotation.java deleted file mode 100644 index f83f0c17e0d..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetConstructorAnnotation.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * 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.kt; - -import com.intellij.psi.PsiAnnotation; -import com.intellij.psi.PsiMethod; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; - -public class JetConstructorAnnotation extends PsiAnnotationWithFlags { - private static final JetConstructorAnnotation NULL_ANNOTATION = new JetConstructorAnnotation(null); - static { - NULL_ANNOTATION.checkInitialized(); - } - - private JetConstructorAnnotation(@Nullable PsiAnnotation psiAnnotation) { - super(psiAnnotation); - } - - @Override - protected void initialize() { - super.initialize(); - hidden = getBooleanAttribute(JvmStdlibNames.JET_CONSTRUCTOR_HIDDEN_FIELD, false); - } - - private boolean hidden; - - /** @deprecated */ - public boolean hidden() { - checkInitialized(); - return hidden; - } - - public static JetConstructorAnnotation get(PsiMethod constructor) { - PsiAnnotation annotation = - JavaAnnotationResolver.findOwnAnnotation(constructor, JvmStdlibNames.JET_CONSTRUCTOR.getFqName().asString()); - return annotation != null ? new JetConstructorAnnotation(annotation) : NULL_ANNOTATION; - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetMethodAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetMethodAnnotation.java deleted file mode 100644 index 88a3e5066ca..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetMethodAnnotation.java +++ /dev/null @@ -1,75 +0,0 @@ -/* - * 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.kt; - -import com.intellij.psi.PsiAnnotation; -import com.intellij.psi.PsiMethod; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; - -public class JetMethodAnnotation extends PsiAnnotationWithFlags { - private static final JetMethodAnnotation NULL_ANNOTATION = new JetMethodAnnotation(null); - static { - NULL_ANNOTATION.checkInitialized(); - } - - private String typeParameters; - private String returnType; - private String propertyType; - - private JetMethodAnnotation(@Nullable PsiAnnotation psiAnnotation) { - super(psiAnnotation); - } - - @Override - protected void initialize() { - super.initialize(); - typeParameters = getStringAttribute(JvmStdlibNames.JET_METHOD_TYPE_PARAMETERS_FIELD, ""); - returnType = getStringAttribute(JvmStdlibNames.JET_METHOD_RETURN_TYPE_FIELD, ""); - propertyType = getStringAttribute(JvmStdlibNames.JET_METHOD_PROPERTY_TYPE_FIELD, ""); - } - - public int kind() { - return flags() & JvmStdlibNames.FLAG_METHOD_KIND_MASK; - } - - @NotNull - public String typeParameters() { - checkInitialized(); - return typeParameters; - } - - @NotNull - public String returnType() { - checkInitialized(); - return returnType; - } - - @NotNull - public String propertyType() { - checkInitialized(); - return propertyType; - } - - public static JetMethodAnnotation get(PsiMethod psiMethod) { - PsiAnnotation annotation = - JavaAnnotationResolver.findOwnAnnotation(psiMethod, JvmStdlibNames.JET_METHOD.getFqName().asString()); - return annotation != null ? new JetMethodAnnotation(annotation) : NULL_ANNOTATION; - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java deleted file mode 100644 index 7ef2fe8d895..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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.kt; - -import com.intellij.psi.PsiAnnotation; -import com.intellij.psi.PsiClass; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; - -public class JetPackageClassAnnotation extends PsiAnnotationWithAbiVersion { - private static final JetPackageClassAnnotation NULL_ANNOTATION = new JetPackageClassAnnotation(null); - static { - NULL_ANNOTATION.checkInitialized(); - } - - private JetPackageClassAnnotation(@Nullable PsiAnnotation psiAnnotation) { - super(psiAnnotation); - } - - @NotNull - public static JetPackageClassAnnotation get(PsiClass psiClass) { - PsiAnnotation annotation = JavaAnnotationResolver.findOwnAnnotation(psiClass, - JvmStdlibNames.JET_PACKAGE_CLASS.getFqName().asString()); - return annotation != null ? new JetPackageClassAnnotation(annotation) : NULL_ANNOTATION; - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetTypeParameterAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetTypeParameterAnnotation.java deleted file mode 100644 index 8d4a5f17758..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetTypeParameterAnnotation.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * 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.kt; - -import com.intellij.psi.PsiAnnotation; -import com.intellij.psi.PsiParameter; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; - -public class JetTypeParameterAnnotation extends PsiAnnotationWrapper { - private static final JetTypeParameterAnnotation NULL_ANNOTATION = new JetTypeParameterAnnotation(null); - static { - NULL_ANNOTATION.checkInitialized(); - } - - private JetTypeParameterAnnotation(@Nullable PsiAnnotation psiAnnotation) { - super(psiAnnotation); - } - - @Override - protected void initialize() { - } - - @NotNull - public static JetTypeParameterAnnotation get(@NotNull PsiParameter psiParameter) { - PsiAnnotation annotation = - JavaAnnotationResolver.findOwnAnnotation(psiParameter, JvmStdlibNames.JET_TYPE_PARAMETER.getFqName().asString()); - return annotation != null ? new JetTypeParameterAnnotation(annotation) : NULL_ANNOTATION; - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java index 97b1771d76b..f64e5e3e1ee 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; public class JetValueParameterAnnotation extends PsiAnnotationWrapper { private static final JetValueParameterAnnotation NULL_ANNOTATION = new JetValueParameterAnnotation(null); + static { NULL_ANNOTATION.checkInitialized(); } @@ -32,7 +33,6 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper { private String name; private String type; private boolean receiver; - private boolean hasDefaultValue; private boolean vararg; private JetValueParameterAnnotation(@Nullable PsiAnnotation psiAnnotation) { @@ -44,7 +44,6 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper { name = getStringAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_NAME_FIELD, ""); type = getStringAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_TYPE_FIELD, ""); receiver = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_RECEIVER_FIELD, false); - hasDefaultValue = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_HAS_DEFAULT_VALUE_FIELD, false); vararg = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_VARARG, false); } @@ -64,11 +63,6 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper { checkInitialized(); return receiver; } - - public boolean hasDefaultValue() { - checkInitialized(); - return hasDefaultValue; - } public boolean vararg() { checkInitialized(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/PsiAnnotationWithFlags.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/PsiAnnotationWithFlags.java index 8b1387bec6e..a7e33ec4bc0 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/PsiAnnotationWithFlags.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/PsiAnnotationWithFlags.java @@ -36,28 +36,4 @@ public abstract class PsiAnnotationWithFlags extends PsiAnnotationWrapper { checkInitialized(); return flags; } - - public final boolean hasPropertyFlag() { - return (flags() & JvmStdlibNames.FLAG_PROPERTY_BIT) != 0; - } - - public final boolean hasForceFinalFlag() { - return (flags() & JvmStdlibNames.FLAG_FORCE_FINAL_BIT) != 0; - } - - public final boolean hasForceOpenFlag() { - return (flags() & JvmStdlibNames.FLAG_FORCE_OPEN_BIT) != 0; - } - - public final boolean hasInternalFlag() { - return (flags() & JvmStdlibNames.FLAG_INTERNAL_BIT) != 0; - } - - public final boolean hasProtectedFlag() { - return (flags() & JvmStdlibNames.FLAG_PROTECTED_BIT) != 0; - } - - public final boolean hasPrivateFlag() { - return (flags() & JvmStdlibNames.FLAG_PRIVATE_BIT) != 0; - } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/ClassPsiDeclarationProviderImpl.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/ClassPsiDeclarationProviderImpl.java index 8f6c3aec594..91a573bbbfe 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/ClassPsiDeclarationProviderImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/ClassPsiDeclarationProviderImpl.java @@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.java.provider; import com.intellij.psi.PsiClass; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.JAVA; @@ -47,7 +46,8 @@ public class ClassPsiDeclarationProviderImpl extends PsiDeclarationProviderBase @Override @NotNull protected MembersCache buildMembersCache() { - return MembersCache.buildMembersByNameCache(new MembersCache(), psiClassFinder, psiClass, null, staticMembers, getDeclarationOrigin() == KOTLIN); + return MembersCache.buildMembersByNameCache(new MembersCache(), psiClassFinder, psiClass, null, staticMembers, + getDeclarationOrigin() == KOTLIN); } @Override @@ -64,7 +64,7 @@ public class ClassPsiDeclarationProviderImpl extends PsiDeclarationProviderBase @NotNull private static DeclarationOrigin determineOrigin(@Nullable PsiClass psiClass) { - return ((psiClass != null) && DescriptorResolverUtils.isKotlinClass(psiClass)) ? KOTLIN : JAVA; + return JAVA; } @Override diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/KotlinNamespacePsiDeclarationProvider.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/KotlinNamespacePsiDeclarationProvider.java deleted file mode 100644 index 01800f91b10..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/KotlinNamespacePsiDeclarationProvider.java +++ /dev/null @@ -1,58 +0,0 @@ -/* - * 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.provider; - -import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiPackage; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; - -import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOTLIN; - -public final class KotlinNamespacePsiDeclarationProvider extends ClassPsiDeclarationProviderImpl implements PackagePsiDeclarationProvider { - @NotNull - private final PsiPackage psiPackage; - - public KotlinNamespacePsiDeclarationProvider( - @NotNull PsiPackage psiPackage, - @NotNull PsiClass psiClass, - @NotNull PsiClassFinder psiClassFinder - ) { - super(psiClass, true, psiClassFinder); - this.psiPackage = psiPackage; - } - - @NotNull - @Override - public PsiPackage getPsiPackage() { - return psiPackage; - } - - @NotNull - @Override - protected MembersCache buildMembersCache() { - MembersCache cacheWithMembers = super.buildMembersCache(); - MembersCache.buildMembersByNameCache(cacheWithMembers, psiClassFinder, null, psiPackage, true, getDeclarationOrigin() == KOTLIN); - return cacheWithMembers; - } - - @NotNull - @Override - public DeclarationOrigin getDeclarationOrigin() { - return KOTLIN; - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java index ebc028a30c4..02cd099fc60 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java @@ -19,16 +19,15 @@ package org.jetbrains.jet.lang.resolve.java.provider; import com.google.common.collect.HashMultimap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Multimap; -import com.intellij.openapi.util.Ref; import com.intellij.psi.*; -import com.intellij.psi.util.MethodSignature; import com.intellij.psi.util.MethodSignatureBackedByPsiMethod; import com.intellij.psi.util.PsiFormatUtil; import com.intellij.util.ArrayUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.*; -import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; +import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker; +import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; +import org.jetbrains.jet.lang.resolve.java.TypeSource; import org.jetbrains.jet.lang.resolve.java.prop.PropertyNameUtils; import org.jetbrains.jet.lang.resolve.java.prop.PropertyParseResult; import org.jetbrains.jet.lang.resolve.java.wrapper.*; @@ -129,9 +128,6 @@ public final class MembersCache { private void process() { for (PsiClass psiClass : psiClasses) { if (!(psiClass instanceof JetJavaMirrorMarker)) { // to filter out JetLightClasses - if (JetClassAnnotation.get(psiClass).kind() == JvmStdlibNames.FLAG_CLASS_KIND_OBJECT) { - processObjectClass(psiClass); - } if (isSamInterface(psiClass)) { processSamInterface(psiClass); } @@ -139,16 +135,6 @@ public final class MembersCache { } } - private void processObjectClass(@NotNull PsiClass psiClass) { - PsiField instanceField = psiClass.findFieldByName(JvmAbi.INSTANCE_FIELD, false); - if (instanceField != null) { - NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(psiClass.getName())); - - TypeSource type = new TypeSource("", instanceField.getType(), instanceField); - namedMembers.addPropertyAccessor(new PropertyPsiDataElement(new PsiFieldWrapper(instanceField), type, null)); - } - } - private void processSamInterface(@NotNull PsiClass psiClass) { NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(psiClass.getName())); namedMembers.setSamInterface(psiClass); @@ -248,9 +234,7 @@ public final class MembersCache { return false; } - //process private accessors - if (member.isPrivate() - && !(member instanceof PsiMethodWrapper && ((PsiMethodWrapper)member).getJetMethodAnnotation().hasPropertyFlag())) { + if (member.isPrivate()) { return false; } @@ -288,90 +272,25 @@ public final class MembersCache { if (propertyParseResult != null && propertyParseResult.isGetter()) { processGetter(ownMethod, method, propertyParseResult); } - else if (propertyParseResult != null && !propertyParseResult.isGetter()) { + else if (propertyParseResult != null) { processSetter(method, propertyParseResult); } - if (!method.getJetMethodAnnotation().hasPropertyFlag()) { - NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(method.getName())); - namedMembers.addMethod(method); - } + NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(method.getName())); + namedMembers.addMethod(method); } + //TODO: manually!!!! private void processSetter(PsiMethodWrapper method, PropertyParseResult propertyParseResult) { + //TODO String propertyName = propertyParseResult.getPropertyName(); - NamedMembers members = getOrCreateEmpty(Name.identifier(propertyName)); - - if (method.getJetMethodAnnotation().hasPropertyFlag()) { - if (method.getParameters().size() == 0) { - // TODO: report error properly - throw new IllegalStateException(); - } - - int i = 0; - - TypeSource receiverType = null; - PsiParameterWrapper p1 = method.getParameter(0); - if (p1.getJetValueParameter().receiver()) { - receiverType = new TypeSource(p1.getJetValueParameter().type(), p1.getPsiParameter().getType(), p1.getPsiParameter()); - ++i; - } - - while (i < method.getParameters().size() && method.getParameter(i).getJetTypeParameter().isDefined()) { - ++i; - } - - if (i + 1 != method.getParameters().size()) { - throw new IllegalStateException(); - } - - PsiParameterWrapper propertyTypeParameter = method.getParameter(i); - TypeSource propertyType = - new TypeSource(method.getJetMethodAnnotation().propertyType(), propertyTypeParameter.getPsiParameter().getType(), - propertyTypeParameter.getPsiParameter()); - - members.addPropertyAccessor(new PropertyPsiDataElement(method, false, propertyType, receiverType)); - } + getOrCreateEmpty(Name.identifier(propertyName)); } private void processGetter(PsiMethod ownMethod, PsiMethodWrapper method, PropertyParseResult propertyParseResult) { + //TODO: String propertyName = propertyParseResult.getPropertyName(); - NamedMembers members = getOrCreateEmpty(Name.identifier(propertyName)); - - // TODO: some java properties too - if (method.getJetMethodAnnotation().hasPropertyFlag()) { - - int i = 0; - - TypeSource receiverType; - if (i < method.getParameters().size() && method.getParameter(i).getJetValueParameter().receiver()) { - PsiParameterWrapper receiverParameter = method.getParameter(i); - receiverType = - new TypeSource(receiverParameter.getJetValueParameter().type(), receiverParameter.getPsiParameter().getType(), - receiverParameter.getPsiParameter()); - ++i; - } - else { - receiverType = null; - } - - while (i < method.getParameters().size() && method.getParameter(i).getJetTypeParameter().isDefined()) { - // TODO: store is reified - ++i; - } - - if (i != method.getParameters().size()) { - // TODO: report error properly - throw new IllegalStateException("something is wrong with method " + ownMethod); - } - - // TODO: what if returnType == null? - PsiType returnType = method.getReturnType(); - assert returnType != null; - TypeSource propertyType = new TypeSource(method.getJetMethodAnnotation().propertyType(), returnType, method.getPsiMethod()); - - members.addPropertyAccessor(new PropertyPsiDataElement(method, true, propertyType, receiverType)); - } + getOrCreateEmpty(Name.identifier(propertyName)); } private void createEmptyEntry(@NotNull Name identifier) { @@ -413,9 +332,6 @@ public final class MembersCache { // Returns null if not SAM interface @Nullable public static PsiMethod getSamInterfaceMethod(@NotNull PsiClass psiClass) { - if (DescriptorResolverUtils.isKotlinClass(psiClass)) { - return null; - } String qualifiedName = psiClass.getQualifiedName(); if (qualifiedName == null || qualifiedName.startsWith(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.asString() + ".")) { return null; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PsiDeclarationProviderFactory.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PsiDeclarationProviderFactory.java index 55389aa2dab..c275cd9b867 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PsiDeclarationProviderFactory.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PsiDeclarationProviderFactory.java @@ -38,12 +38,6 @@ public final class PsiDeclarationProviderFactory { return new ClassPsiDeclarationProviderImpl(psiClass, false, psiClassFinder); } - @NotNull - public KotlinNamespacePsiDeclarationProvider createDeclarationForKotlinNamespace( - @NotNull PsiPackage psiPackage, @NotNull PsiClass psiClass) { - return new KotlinNamespacePsiDeclarationProvider(psiPackage, psiClass, psiClassFinder); - } - @NotNull public PackagePsiDeclarationProvider createDeclarationProviderForNamespaceWithoutMembers(@NotNull PsiPackage psiPackage) { return new PackagePsiDeclarationProviderImpl(psiPackage, psiClassFinder); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java deleted file mode 100644 index 5f59d056aee..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java +++ /dev/null @@ -1,168 +0,0 @@ -/* - * 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.psi.PsiClass; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassKind; -import org.jetbrains.jet.lang.descriptors.Modality; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; -import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; -import org.jetbrains.jet.lang.resolve.java.kt.JetClassObjectAnnotation; -import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; -import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.FqNameBase; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; - -import javax.inject.Inject; -import java.util.Collections; - -import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod; -import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod; -import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName; - -public final class JavaClassObjectResolver { - - private BindingTrace trace; - private JavaSemanticServices semanticServices; - private JavaSupertypeResolver supertypesResolver; - - @Inject - public void setSupertypesResolver(JavaSupertypeResolver supertypesResolver) { - this.supertypesResolver = supertypesResolver; - } - - @Inject - public void setTrace(BindingTrace trace) { - this.trace = trace; - } - - @Inject - public void setSemanticServices(JavaSemanticServices semanticServices) { - this.semanticServices = semanticServices; - } - - @Nullable - public ClassDescriptorFromJvmBytecode createClassObjectDescriptor( - @NotNull ClassDescriptor containing, - @NotNull PsiClass psiClass - ) { - DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass); - - if (psiClass.isEnum()) { - return createClassObjectDescriptorForEnum(containing, psiClass); - } - - if (!DescriptorResolverUtils.isKotlinClass(psiClass)) { - return null; - } - - PsiClass classObjectPsiClass = getClassObjectPsiClass(psiClass); - if (classObjectPsiClass == null) { - return null; - } - - return createClassObjectFromPsi(containing, classObjectPsiClass); - } - - @NotNull - private ClassDescriptorFromJvmBytecode createClassObjectFromPsi( - @NotNull ClassDescriptor containing, - @NotNull PsiClass classObjectPsiClass - ) { - String qualifiedName = classObjectPsiClass.getQualifiedName(); - assert qualifiedName != null; - FqName fqName = new FqName(qualifiedName); - ClassPsiDeclarationProvider classObjectData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(classObjectPsiClass); - ClassDescriptorFromJvmBytecode classObjectDescriptor - = new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false); - classObjectDescriptor.setSupertypes(supertypesResolver.getSupertypes(classObjectDescriptor, - new PsiClassWrapper(classObjectPsiClass), - classObjectData, - Collections.emptyList())); - setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, classObjectData, getClassObjectName(containing.getName())); - return classObjectDescriptor; - } - - @NotNull - private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum( - @NotNull ClassDescriptor containing, - @NotNull PsiClass psiClass - ) { - ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, psiClass); - - classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace)); - classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace)); - - return classObjectDescriptor; - } - - @NotNull - private ClassDescriptorFromJvmBytecode createSyntheticClassObject( - @NotNull ClassDescriptor containing, - @NotNull PsiClass psiClass - ) { - FqNameUnsafe fqName = DescriptorResolverUtils.getFqNameForClassObject(psiClass); - ClassDescriptorFromJvmBytecode classObjectDescriptor = - new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false); - ClassPsiDeclarationProvider data = semanticServices.getPsiDeclarationProviderFactory().createSyntheticClassObjectClassData(psiClass); - setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, data, getClassObjectName(containing.getName().asString())); - return classObjectDescriptor; - } - - private void setUpClassObjectDescriptor( - @NotNull ClassDescriptorFromJvmBytecode classObjectDescriptor, - @NotNull ClassDescriptor containing, - @NotNull FqNameBase fqName, - @NotNull ClassPsiDeclarationProvider data, - @NotNull Name classObjectName - ) { - classObjectDescriptor.setName(classObjectName); - classObjectDescriptor.setModality(Modality.FINAL); - classObjectDescriptor.setVisibility(containing.getVisibility()); - classObjectDescriptor.setTypeParameterDescriptors(Collections.emptyList()); - classObjectDescriptor.createTypeConstructor(); - JavaClassNonStaticMembersScope classMembersScope = new JavaClassNonStaticMembersScope(classObjectDescriptor, data, semanticServices); - WritableScopeImpl writableScope = - new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, "Member lookup scope"); - writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); - classObjectDescriptor.setScopeForMemberLookup(writableScope); - classObjectDescriptor.setScopeForConstructorResolve(classMembersScope); - } - - - @Nullable - private static PsiClass getClassObjectPsiClass(@NotNull PsiClass ownerClass) { - for (PsiClass inner : ownerClass.getInnerClasses()) { - if (JetClassObjectAnnotation.get(inner).isDefined()) { - return inner; - } - } - return null; - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 5dfb7efe856..80d2840ae5d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -32,7 +32,6 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; -import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; import org.jetbrains.jet.lang.resolve.java.provider.MembersCache; import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; @@ -44,16 +43,20 @@ import org.jetbrains.jet.lang.resolve.name.FqNameBase; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; +import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import javax.inject.Inject; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; + +import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod; +import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod; +import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName; public final class JavaClassResolver { @@ -85,7 +88,6 @@ public final class JavaClassResolver { private JavaAnnotationResolver annotationResolver; private PsiClassFinder psiClassFinder; private JavaNamespaceResolver namespaceResolver; - private JavaClassObjectResolver classObjectResolver; private JavaSupertypeResolver supertypesResolver; private JavaFunctionResolver functionResolver; private DeserializedDescriptorResolver kotlinDescriptorResolver; @@ -108,11 +110,6 @@ public final class JavaClassResolver { this.signatureResolver = signatureResolver; } - @Inject - public void setClassObjectResolver(JavaClassObjectResolver classObjectResolver) { - this.classObjectResolver = classObjectResolver; - } - @Inject public void setSemanticServices(JavaSemanticServices semanticServices) { this.semanticServices = semanticServices; @@ -258,6 +255,7 @@ public final class JavaClassResolver { return doCreateClassDescriptor(fqName, psiClass, taskList, containingDeclaration); } + @NotNull private ClassDescriptorFromJvmBytecode doCreateClassDescriptor( @NotNull FqName fqName, @@ -265,12 +263,7 @@ public final class JavaClassResolver { @NotNull PostponedTasks taskList, @NotNull ClassOrNamespaceDescriptor containingDeclaration ) { - JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass); - if (jetClassAnnotation.isDefined()) { - AbiVersionUtil.checkAbiVersion(psiClass, jetClassAnnotation.getAbiVersion(), trace); - } - - ClassKind kind = getClassKind(psiClass, jetClassAnnotation); + ClassKind kind = getClassKind(psiClass); ClassPsiDeclarationProvider classData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(psiClass); ClassDescriptorFromJvmBytecode classDescriptor = new ClassDescriptorFromJvmBytecode( containingDeclaration, kind, isInnerClass(psiClass)); @@ -279,12 +272,12 @@ public final class JavaClassResolver { classDescriptor.setName(Name.identifier(psiClass.getName())); List typeParameterDescriptorInitializations - = signatureResolver.createUninitializedClassTypeParameters(psiClass, classDescriptor); + = JavaSignatureResolver.createUninitializedClassTypeParameters(psiClass, classDescriptor); classDescriptor.setTypeParameterDescriptors(getTypeParametersDescriptors(typeParameterDescriptorInitializations)); List supertypes = Lists.newArrayList(); classDescriptor.setSupertypes(supertypes); - classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass, jetClassAnnotation)); + classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass)); classDescriptor.setModality(resolveModality(psiClass, classDescriptor)); classDescriptor.createTypeConstructor(); JavaClassNonStaticMembersScope membersScope = new JavaClassNonStaticMembersScope(classDescriptor, classData, semanticServices); @@ -298,9 +291,9 @@ public final class JavaClassResolver { List classTypeParameters = classDescriptor.getTypeConstructor().getParameters(); supertypes.addAll(supertypesResolver.getSupertypes(classDescriptor, new PsiClassWrapper(psiClass), classData, classTypeParameters)); - ClassDescriptorFromJvmBytecode classObjectDescriptor = classObjectResolver.createClassObjectDescriptor(classDescriptor, psiClass); - cache(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectDescriptor); - if (classObjectDescriptor != null) { + if (psiClass.isEnum()) { + ClassDescriptorFromJvmBytecode classObjectDescriptor = createClassObjectDescriptorForEnum(classDescriptor, psiClass); + cache(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectDescriptor); classDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor); } @@ -468,20 +461,65 @@ public final class JavaClassResolver { } @NotNull - private static ClassKind getClassKind(@NotNull PsiClass psiClass, @NotNull JetClassAnnotation jetClassAnnotation) { + private static ClassKind getClassKind(@NotNull PsiClass psiClass) { if (psiClass.isInterface()) { return (psiClass.isAnnotationType() ? ClassKind.ANNOTATION_CLASS : ClassKind.TRAIT); } if (psiClass.isEnum()) { return ClassKind.ENUM_CLASS; } - else { - return jetClassAnnotation.kind() == JvmStdlibNames.FLAG_CLASS_KIND_OBJECT ? ClassKind.OBJECT : ClassKind.CLASS; - } + return ClassKind.CLASS; } @Nullable public ClassDescriptor resolveClass(FqName name) { return resolveClass(name, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); } + + @NotNull + private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum( + @NotNull ClassDescriptor containing, + @NotNull PsiClass psiClass + ) { + ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, psiClass); + + classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace)); + classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace)); + + return classObjectDescriptor; + } + + @NotNull + private ClassDescriptorFromJvmBytecode createSyntheticClassObject( + @NotNull ClassDescriptor containing, + @NotNull PsiClass psiClass + ) { + ClassDescriptorFromJvmBytecode classObjectDescriptor = + new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false); + ClassPsiDeclarationProvider data = + semanticServices.getPsiDeclarationProviderFactory().createSyntheticClassObjectClassData(psiClass); + setUpClassObjectDescriptor(classObjectDescriptor, containing, data, getClassObjectName(containing.getName().asString())); + return classObjectDescriptor; + } + + private void setUpClassObjectDescriptor( + @NotNull ClassDescriptorFromJvmBytecode classObjectDescriptor, + @NotNull ClassDescriptor containing, + @NotNull ClassPsiDeclarationProvider data, + @NotNull Name classObjectName + ) { + classObjectDescriptor.setName(classObjectName); + classObjectDescriptor.setModality(Modality.FINAL); + classObjectDescriptor.setVisibility(containing.getVisibility()); + classObjectDescriptor.setTypeParameterDescriptors(Collections.emptyList()); + classObjectDescriptor.createTypeConstructor(); + JavaClassNonStaticMembersScope classMembersScope = + new JavaClassNonStaticMembersScope(classObjectDescriptor, data, semanticServices); + WritableScopeImpl writableScope = + new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, + "Member lookup scope"); + writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); + classObjectDescriptor.setScopeForMemberLookup(writableScope); + classObjectDescriptor.setScopeForConstructorResolve(classMembersScope); + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java index 00e6f40e468..c6cd8b4f92f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java @@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData; -import org.jetbrains.jet.lang.resolve.java.kt.JetConstructorAnnotation; import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.Name; @@ -102,7 +101,8 @@ public final class JavaConstructorResolver { containingClass, Collections.emptyList(), true); - constructorDescriptor.initialize(typeParameters, Collections.emptyList(), constructorVisibility, isStatic); + constructorDescriptor + .initialize(typeParameters, Collections.emptyList(), constructorVisibility, isStatic); constructors.add(constructorDescriptor); trace.record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor); } @@ -175,27 +175,14 @@ public final class JavaConstructorResolver { ) { PsiMethodWrapper constructor = new PsiMethodWrapper(psiConstructor); - JetConstructorAnnotation constructorAnnotation = constructor.getJetConstructorAnnotation(); - //noinspection deprecation - if (constructorAnnotation.hidden()) { - return null; - } - - // Do not resolve kotlin constructors without JetConstructorAnnotation - if (DescriptorResolverUtils.isKotlinClass(psiClass) && !constructorAnnotation.isDefined()) { - return null; - } - if (trace.get(BindingContext.CONSTRUCTOR, psiConstructor) != null) { return trace.get(BindingContext.CONSTRUCTOR, psiConstructor); } - boolean primary = constructor.getJetConstructorAnnotation().isDefined(); - ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl( classDescriptor, Collections.emptyList(), // TODO - primary); + false); String context = "constructor of class " + psiClass.getQualifiedName(); JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors( @@ -219,7 +206,7 @@ public final class JavaConstructorResolver { constructorDescriptor.initialize(classDescriptor.getTypeConstructor().getParameters(), valueParameterDescriptors.getDescriptors(), - DescriptorResolverUtils.resolveVisibility(psiConstructor, constructorAnnotation), + DescriptorResolverUtils.resolveVisibility(psiConstructor), aStatic); trace.record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor); return constructorDescriptor; 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 ac096b902d7..d37f832fe4e 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 @@ -34,7 +34,6 @@ import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesPropagationData; -import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils; import org.jetbrains.jet.lang.resolve.java.provider.*; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.Name; @@ -115,11 +114,6 @@ public final class JavaFunctionResolver { return null; } - // TODO: ugly - if (method.getJetMethodAnnotation().hasPropertyFlag()) { - return null; - } - PsiMethod psiMethod = method.getPsiMethod(); PsiClass containingClass = psiMethod.getContainingClass(); if (declarationOrigin == KOTLIN) { @@ -139,7 +133,7 @@ public final class JavaFunctionResolver { ownerDescriptor, annotationResolver.resolveAnnotations(psiMethod), Name.identifier(method.getName()), - DescriptorKindUtils.flagsToKind(method.getJetMethodAnnotation().kind()) + CallableMemberDescriptor.Kind.DECLARATION ); String context = "method " + method.getName() + " in class " + psiClass.getQualifiedName(); @@ -159,7 +153,7 @@ public final class JavaFunctionResolver { List signatureErrors = Lists.newArrayList(); List superFunctions; - if (ownerDescriptor instanceof ClassDescriptor && !method.getJetMethodAnnotation().isDefined()) { // don't propagate for Kotlin functions + if (ownerDescriptor instanceof ClassDescriptor) { SignaturesPropagationData signaturesPropagationData = new SignaturesPropagationData( (ClassDescriptor) ownerDescriptor, returnType, valueParameterDescriptors, methodTypeParameters, method, trace); superFunctions = signaturesPropagationData.getSuperFunctions(); @@ -192,8 +186,8 @@ public final class JavaFunctionResolver { methodTypeParameters, valueParameterDescriptors.getDescriptors(), returnType, - DescriptorResolverUtils.resolveModality(method, method.isFinal()), - DescriptorResolverUtils.resolveVisibility(psiMethod, method.getJetMethodAnnotation()), + Modality.convertFromFlags(method.isAbstract(), !method.isFinal()), + DescriptorResolverUtils.resolveVisibility(psiMethod), /*isInline = */ false ); @@ -210,8 +204,8 @@ public final class JavaFunctionResolver { } if (!RawTypesCheck.hasRawTypesInHierarchicalSignature(psiMethod) - && JavaMethodSignatureUtil.isMethodReturnTypeCompatible(psiMethod) - && !containsErrorType(superFunctions, functionDescriptorImpl)) { + && JavaMethodSignatureUtil.isMethodReturnTypeCompatible(psiMethod) + && !containsErrorType(superFunctions, functionDescriptorImpl)) { if (signatureErrors.isEmpty()) { checkFunctionsOverrideCorrectly(method, superFunctions, functionDescriptorImpl); } @@ -276,13 +270,11 @@ public final class JavaFunctionResolver { Set functionsFromCurrent = Sets.newHashSet(); for (PsiMethodWrapper method : namedMembers.getMethods()) { - SimpleFunctionDescriptor function = resolveMethodToFunctionDescriptor(psiClass, method, scopeData.getDeclarationOrigin(), owner, true); + SimpleFunctionDescriptor function = + resolveMethodToFunctionDescriptor(psiClass, method, scopeData.getDeclarationOrigin(), owner, true); if (function != null) { functionsFromCurrent.add(function); - - if (!DescriptorResolverUtils.isKotlinClass(psiClass)) { - ContainerUtil.addIfNotNull(functionsFromCurrent, resolveSamAdapter(function)); - } + ContainerUtil.addIfNotNull(functionsFromCurrent, resolveSamAdapter(function)); } } @@ -296,20 +288,20 @@ public final class JavaFunctionResolver { ClassDescriptor classDescriptor = (ClassDescriptor) owner; OverrideResolver.generateOverridesInFunctionGroup(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, - new OverrideResolver.DescriptorSink() { - @Override - public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) { - fakeOverrides.add((FunctionDescriptor) fakeOverride); - } + new OverrideResolver.DescriptorSink() { + @Override + public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) { + fakeOverrides.add((FunctionDescriptor) fakeOverride); + } - @Override - public void conflict( - @NotNull CallableMemberDescriptor fromSuper, - @NotNull CallableMemberDescriptor fromCurrent - ) { - // nop - } - }); + @Override + public void conflict( + @NotNull CallableMemberDescriptor fromSuper, + @NotNull CallableMemberDescriptor fromCurrent + ) { + // nop + } + }); } OverrideResolver.resolveUnknownVisibilities(fakeOverrides, trace); @@ -426,18 +418,12 @@ public final class JavaFunctionResolver { @NotNull TypeVariableResolver typeVariableResolver ) { - String returnTypeFromAnnotation = method.getJetMethodAnnotation().returnType(); + TypeUsage typeUsage = JavaTypeTransformer + .adjustTypeUsageWithMutabilityAnnotations(method.getPsiMethod(), TypeUsage.MEMBER_SIGNATURE_COVARIANT); + JetType transformedType = typeTransformer.transformToType(returnType, typeUsage, typeVariableResolver); - JetType transformedType; - if (returnTypeFromAnnotation.length() > 0) { - transformedType = typeTransformer.transformToType(returnTypeFromAnnotation, typeVariableResolver); - } - else { - TypeUsage typeUsage = JavaTypeTransformer.adjustTypeUsageWithMutabilityAnnotations(method.getPsiMethod(), TypeUsage.MEMBER_SIGNATURE_COVARIANT); - transformedType = typeTransformer.transformToType(returnType, typeUsage, typeVariableResolver); - } - - if (JavaAnnotationResolver.findAnnotationWithExternal(method.getPsiMethod(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) != + if (JavaAnnotationResolver + .findAnnotationWithExternal(method.getPsiMethod(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) != null) { return TypeUtils.makeNullableAsSpecified(transformedType, false); } @@ -473,7 +459,11 @@ public final class JavaFunctionResolver { return false; } - private static SimpleFunctionDescriptor recordSamConstructor(ClassDescriptorFromJvmBytecode klass, SimpleFunctionDescriptor constructorFunction, BindingTrace trace) { + private static SimpleFunctionDescriptor recordSamConstructor( + ClassDescriptorFromJvmBytecode klass, + SimpleFunctionDescriptor constructorFunction, + BindingTrace trace + ) { trace.record(JavaBindingContext.SAM_CONSTRUCTOR_TO_INTERFACE, constructorFunction, klass); trace.record(BindingContext.SOURCE_DESCRIPTOR_FOR_SYNTHESIZED, constructorFunction, klass); return constructorFunction; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java index fc72897b874..485e62ac552 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java @@ -20,8 +20,6 @@ import com.intellij.psi.PsiClass; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; -import org.jetbrains.jet.lang.resolve.java.JvmAbi; -import org.jetbrains.jet.lang.resolve.java.kt.JetClassObjectAnnotation; import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -56,19 +54,12 @@ public final class JavaInnerClassResolver { PsiClass[] innerPsiClasses = psiClass.getInnerClasses(); List result = new ArrayList(innerPsiClasses.length); for (PsiClass innerPsiClass : innerPsiClasses) { - if (shouldBeIgnored(innerPsiClass)) { - continue; - } ClassDescriptor classDescriptor = resolveInnerClass(innerPsiClass); result.add(classDescriptor); } return result; } - private static boolean shouldBeIgnored(PsiClass innerPsiClass) { - return JetClassObjectAnnotation.get(innerPsiClass).isDefined(); - } - @NotNull private ClassDescriptor resolveInnerClass(@NotNull PsiClass innerPsiClass) { String name = innerPsiClass.getQualifiedName(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java index 027fef05730..207164c5f42 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java @@ -37,7 +37,6 @@ import org.jetbrains.jet.lang.resolve.java.provider.MembersCache; import org.jetbrains.jet.lang.resolve.java.scope.JavaBaseScope; import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope; import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScopeWithoutMembers; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -201,7 +200,7 @@ public final class JavaNamespaceResolver { } private static boolean isOldKotlinPackageClass(@NotNull PsiClass psiClass) { - return new PsiClassWrapper(psiClass).getJetPackageClass().isDefined(); + return hasAnnotation(psiClass, JvmStdlibNames.JET_PACKAGE_CLASS.getFqName()); } private static boolean hasKotlinPackageAnnotation(@NotNull PsiClass psiClass) { 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 447286c7e7f..1642a56cb53 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 @@ -30,8 +30,6 @@ import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeFieldSignatureData; -import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils; -import org.jetbrains.jet.lang.resolve.java.kt.JetMethodAnnotation; import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider; import org.jetbrains.jet.lang.resolve.java.wrapper.*; @@ -45,6 +43,7 @@ import java.util.*; import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.JAVA; +//TODO: getters and setter are not working public final class JavaPropertyResolver { private JavaSemanticServices semanticServices; @@ -174,17 +173,16 @@ public final class JavaPropertyResolver { PropertyPsiDataElement characteristicMember = psiData.getCharacteristicMember(); - Visibility visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi(), null); + Visibility visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi()); CallableMemberDescriptor.Kind kind = CallableMemberDescriptor.Kind.DECLARATION; PropertyPsiDataElement getter = psiData.getGetter(); if (getter != null) { - JetMethodAnnotation methodAnnotation = ((PsiMethodWrapper) getter.getMember()).getJetMethodAnnotation(); - visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi(), methodAnnotation); - kind = DescriptorKindUtils.flagsToKind(methodAnnotation.kind()); + visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi()); } - PropertyDescriptorImpl propertyDescriptor = createPropertyDescriptor(owner, propertyName, psiData, isFinal, isVar, visibility, kind); + PropertyDescriptorImpl propertyDescriptor = + createPropertyDescriptor(owner, propertyName, psiData, isFinal, isVar, visibility, kind); PropertyGetterDescriptorImpl getterDescriptor = resolveGetter(visibility, kind, getter, propertyDescriptor); PropertySetterDescriptorImpl setterDescriptor = resolveSetter(psiData, kind, propertyDescriptor); @@ -209,9 +207,7 @@ public final class JavaPropertyResolver { ); initializeSetterAndGetter(propertyDescriptor, getterDescriptor, setterDescriptor, propertyType, psiData); - if (kind == CallableMemberDescriptor.Kind.DECLARATION) { - trace.record(BindingContext.VARIABLE, psiData.getCharacteristicPsi(), propertyDescriptor); - } + trace.record(BindingContext.VARIABLE, psiData.getCharacteristicPsi(), propertyDescriptor); if (scopeData.getDeclarationOrigin() == JAVA) { trace.record(JavaBindingContext.IS_DECLARED_IN_JAVA, propertyDescriptor); @@ -277,8 +273,8 @@ public final class JavaPropertyResolver { return new PropertyDescriptorImpl( owner, annotationResolver.resolveAnnotations(psiData.getCharacteristicPsi()), - DescriptorResolverUtils.resolveModality(psiData.getCharacteristicMember().getMember(), - isFinal || psiData.isPropertyForNamedObject()), + Modality.convertFromFlags(psiData.getCharacteristicMember().getMember().isAbstract(), + !(isFinal || psiData.isPropertyForNamedObject())), visibility, isVar, propertyName, @@ -310,6 +306,7 @@ public final class JavaPropertyResolver { return propertyType; } + //TODO: doesn't work private static void initializeSetterAndGetter( @NotNull PropertyDescriptor propertyDescriptor, @Nullable PropertyGetterDescriptorImpl getterDescriptor, @@ -325,13 +322,11 @@ public final class JavaPropertyResolver { assert setter != null; List parameters = ((PsiMethodWrapper) setter.getMember()).getParameters(); assert parameters.size() != 0; - int valueIndex = parameters.size() - 1; - PsiParameterWrapper valueParameter = parameters.get(valueIndex); setterDescriptor.initialize(new ValueParameterDescriptorImpl( setterDescriptor, 0, Collections.emptyList(), - Name.identifierNoValidate(valueParameter.getJetValueParameter().name()), + Name.identifierNoValidate(""), propertyDescriptor.getType(), false, null)); @@ -368,12 +363,11 @@ public final class JavaPropertyResolver { if (setter == null) { return null; } - Visibility setterVisibility = DescriptorResolverUtils.resolveVisibility(setter.getMember().getPsiMember(), null); + Visibility setterVisibility = DescriptorResolverUtils.resolveVisibility(setter.getMember().getPsiMember()); if (setter.getMember() instanceof PsiMethodWrapper) { setterVisibility = DescriptorResolverUtils.resolveVisibility( - setter.getMember().getPsiMember(), - ((PsiMethodWrapper) setter.getMember()) - .getJetMethodAnnotation()); + setter.getMember().getPsiMember() + ); } return new PropertySetterDescriptorImpl( propertyDescriptor, diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java index 0f99a2a9d15..25b3ecc404c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java @@ -21,12 +21,14 @@ import com.intellij.psi.*; import jet.typeinfo.TypeInfoVariance; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.*; -import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; @@ -72,7 +74,10 @@ public final class JavaSignatureResolver { @Nullable private final List upperBoundsForKotlin; - private TypeParameterDescriptorInitialization(@NotNull TypeParameterDescriptorImpl descriptor, @NotNull PsiTypeParameter psiTypeParameter) { + private TypeParameterDescriptorInitialization( + @NotNull TypeParameterDescriptorImpl descriptor, + @NotNull PsiTypeParameter psiTypeParameter + ) { this.origin = TypeParameterDescriptorOrigin.JAVA; this.descriptor = descriptor; this.psiTypeParameter = psiTypeParameter; @@ -96,7 +101,6 @@ public final class JavaSignatureResolver { } - @NotNull private static PsiTypeParameter getPsiTypeParameterByName(PsiTypeParameterListOwner clazz, String name) { for (PsiTypeParameter typeParameter : clazz.getTypeParameters()) { @@ -108,7 +112,6 @@ public final class JavaSignatureResolver { } - private abstract class JetSignatureTypeParameterVisitor extends JetSignatureExceptionsAdapter { @NotNull @@ -124,8 +127,8 @@ public final class JavaSignatureResolver { @NotNull PsiTypeParameterListOwner psiOwner, @NotNull String name, @NotNull TypeVariableResolver typeVariableResolver, - @NotNull TypeParameterDescriptorImpl typeParameterDescriptor) - { + @NotNull TypeParameterDescriptorImpl typeParameterDescriptor + ) { if (name.isEmpty()) { throw new IllegalStateException(); } @@ -164,7 +167,8 @@ public final class JavaSignatureResolver { @Override public void visitFormalTypeParameterEnd() { PsiTypeParameter psiTypeParameter = getPsiTypeParameterByName(psiOwner, name); - TypeParameterDescriptorInitialization typeParameterDescriptorInitialization = new TypeParameterDescriptorInitialization(typeParameterDescriptor, psiTypeParameter, upperBounds); + TypeParameterDescriptorInitialization typeParameterDescriptorInitialization = + new TypeParameterDescriptorInitialization(typeParameterDescriptor, psiTypeParameter, upperBounds); done(typeParameterDescriptorInitialization); } @@ -182,7 +186,11 @@ public final class JavaSignatureResolver { private final TypeVariableResolver typeVariableResolver; - private JetSignatureTypeParametersVisitor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull PsiTypeParameterListOwner psiOwner, @NotNull String context) { + private JetSignatureTypeParametersVisitor( + @NotNull DeclarationDescriptor containingDeclaration, + @NotNull PsiTypeParameterListOwner psiOwner, + @NotNull String context + ) { this.containingDeclaration = containingDeclaration; this.psiOwner = psiOwner; @@ -219,37 +227,41 @@ public final class JavaSignatureResolver { } } - /** + /** * @see #resolveMethodTypeParametersFromJetSignature(String, PsiMethod, DeclarationDescriptor) */ - private List resolveClassTypeParametersFromJetSignature(String jetSignature, - final PsiClass clazz, final ClassDescriptor classDescriptor) { + private List resolveClassTypeParametersFromJetSignature( + String jetSignature, + final PsiClass clazz, final ClassDescriptor classDescriptor + ) { String context = "class " + clazz.getQualifiedName(); - JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(classDescriptor, clazz, context) { - @Override - public JetSignatureVisitor visitSuperclass() { - // TODO - return new JetSignatureAdapter(); - } + JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = + new JetSignatureTypeParametersVisitor(classDescriptor, clazz, context) { + @Override + public JetSignatureVisitor visitSuperclass() { + // TODO + return new JetSignatureAdapter(); + } - @Override - public JetSignatureVisitor visitInterface() { - // TODO - return new JetSignatureAdapter(); - } - }; + @Override + public JetSignatureVisitor visitInterface() { + // TODO + return new JetSignatureAdapter(); + } + }; new JetSignatureReader(jetSignature).accept(jetSignatureTypeParametersVisitor); return jetSignatureTypeParametersVisitor.r; } - private static List makeUninitializedTypeParameters( - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull PsiTypeParameter[] typeParameters - ) { + private static List makeUninitializedTypeParameters( + @NotNull DeclarationDescriptor containingDeclaration, + @NotNull PsiTypeParameter[] typeParameters + ) { List result = Lists.newArrayList(); for (PsiTypeParameter typeParameter : typeParameters) { - TypeParameterDescriptorInitialization typeParameterDescriptor = makeUninitializedTypeParameter(containingDeclaration, typeParameter); + TypeParameterDescriptorInitialization typeParameterDescriptor = + makeUninitializedTypeParameter(containingDeclaration, typeParameter); result.add(typeParameterDescriptor); } return result; @@ -271,12 +283,15 @@ public final class JavaSignatureResolver { return new TypeParameterDescriptorInitialization(typeParameterDescriptor, psiTypeParameter); } - private void initializeTypeParameter(TypeParameterDescriptorInitialization typeParameter, TypeVariableResolver typeVariableByPsiResolver) { + private void initializeTypeParameter( + TypeParameterDescriptorInitialization typeParameter, + TypeVariableResolver typeVariableByPsiResolver + ) { TypeParameterDescriptorImpl typeParameterDescriptor = typeParameter.descriptor; if (typeParameter.origin == TypeParameterDescriptorOrigin.KOTLIN) { List upperBoundsForKotlin = typeParameter.upperBoundsForKotlin; assert upperBoundsForKotlin != null; - if (upperBoundsForKotlin.size() == 0){ + if (upperBoundsForKotlin.size() == 0) { typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType()); } else { @@ -289,15 +304,19 @@ public final class JavaSignatureResolver { } else { PsiClassType[] referencedTypes = typeParameter.psiTypeParameter.getExtendsList().getReferencedTypes(); - if (referencedTypes.length == 0){ + if (referencedTypes.length == 0) { typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType()); } else if (referencedTypes.length == 1) { - typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer().transformToType(referencedTypes[0], TypeUsage.UPPER_BOUND, typeVariableByPsiResolver)); + typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer() + .transformToType(referencedTypes[0], TypeUsage.UPPER_BOUND, + typeVariableByPsiResolver)); } else { for (PsiClassType referencedType : referencedTypes) { - typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer().transformToType(referencedType, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver)); + typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer() + .transformToType(referencedType, TypeUsage.UPPER_BOUND, + typeVariableByPsiResolver)); } } } @@ -319,22 +338,22 @@ public final class JavaSignatureResolver { for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) { prevTypeParameters.add(psiTypeParameter.descriptor); initializeTypeParameter(psiTypeParameter, - TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, typeParametersOwner, context)); + TypeVariableResolvers + .typeVariableResolverFromTypeParameters(typeParameters, typeParametersOwner, context)); } } - public List createUninitializedClassTypeParameters( + @NotNull + public static List createUninitializedClassTypeParameters( PsiClass psiClass, ClassDescriptor classDescriptor ) { - JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass); - - if (jetClassAnnotation.signature().length() > 0) { - return resolveClassTypeParametersFromJetSignature( - jetClassAnnotation.signature(), psiClass, classDescriptor); + List result = Lists.newArrayList(); + for (PsiTypeParameter typeParameter : psiClass.getTypeParameters()) { + TypeParameterDescriptorInitialization typeParameterDescriptor = makeUninitializedTypeParameter(classDescriptor, typeParameter); + result.add(typeParameterDescriptor); } - - return makeUninitializedTypeParameters(classDescriptor, psiClass.getTypeParameters()); + return result; } @@ -343,15 +362,9 @@ public final class JavaSignatureResolver { @NotNull DeclarationDescriptor functionDescriptor ) { - List typeParametersIntialization; PsiMethod psiMethod = method.getPsiMethod(); - if (method.getJetMethodAnnotation().typeParameters().length() > 0) { - typeParametersIntialization = resolveMethodTypeParametersFromJetSignature( - method.getJetMethodAnnotation().typeParameters(), psiMethod, functionDescriptor); - } - else { - typeParametersIntialization = makeUninitializedTypeParameters(functionDescriptor, psiMethod.getTypeParameters()); - } + List typeParametersIntialization = + makeUninitializedTypeParameters(functionDescriptor, psiMethod.getTypeParameters()); PsiClass psiMethodContainingClass = psiMethod.getContainingClass(); assert psiMethodContainingClass != null; @@ -370,15 +383,16 @@ public final class JavaSignatureResolver { /** * @see #resolveClassTypeParametersFromJetSignature(String, PsiClass, ClassDescriptor) */ - private List resolveMethodTypeParametersFromJetSignature(String jetSignature, - PsiMethod method, DeclarationDescriptor functionDescriptor) - { + private List resolveMethodTypeParametersFromJetSignature( + String jetSignature, + PsiMethod method, DeclarationDescriptor functionDescriptor + ) { PsiClass methodContainingClass = method.getContainingClass(); assert methodContainingClass != null; String context = "method " + method.getName() + " in class " + methodContainingClass.getQualifiedName(); - JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(functionDescriptor, method, context); + JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = + new JetSignatureTypeParametersVisitor(functionDescriptor, method, context); new JetSignatureReader(jetSignature).acceptFormalTypeParametersOnly(jetSignatureTypeParametersVisitor); return jetSignatureTypeParametersVisitor.r; } - } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java index a5d01dd296f..65a5d41cc75 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java @@ -18,7 +18,6 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiClassType; -import jet.typeinfo.TypeInfoVariance; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; @@ -33,10 +32,6 @@ import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.rt.signature.JetSignatureAdapter; -import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; -import org.jetbrains.jet.rt.signature.JetSignatureReader; -import org.jetbrains.jet.rt.signature.JetSignatureVisitor; import javax.inject.Inject; import java.util.ArrayList; @@ -48,7 +43,6 @@ import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOT public final class JavaSupertypeResolver { private BindingTrace trace; - private JavaSemanticServices semanticServices; private JavaTypeTransformer typeTransformer; private JavaClassResolver classResolver; @@ -57,11 +51,6 @@ public final class JavaSupertypeResolver { this.trace = trace; } - @Inject - public void setSemanticServices(JavaSemanticServices semanticServices) { - this.semanticServices = semanticServices; - } - @Inject public void setTypeTransformer(JavaTypeTransformer typeTransformer) { this.typeTransformer = typeTransformer; @@ -83,15 +72,10 @@ public final class JavaSupertypeResolver { String context = "class " + psiClass.getQualifiedName(); - if (psiClass.getJetClass().signature().length() > 0) { - readSuperTypes(psiClass, typeParameters, classDescriptor, result, context); - } - else { - TypeVariableResolver typeVariableResolverForSupertypes = - TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context); - transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), typeVariableResolverForSupertypes); - transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), typeVariableResolverForSupertypes); - } + TypeVariableResolver typeVariableResolverForSupertypes = + TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context); + transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), typeVariableResolverForSupertypes); + transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), typeVariableResolverForSupertypes); reportIncompleteHierarchyForErrorTypes(classDescriptor, result); @@ -101,43 +85,6 @@ public final class JavaSupertypeResolver { return result; } - private void readSuperTypes( - PsiClassWrapper psiClass, - List typeParameters, - ClassDescriptor classDescriptor, - final List result, - String context - ) { - final TypeVariableResolver typeVariableResolver = - TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context); - - new JetSignatureReader(psiClass.getJetClass().signature()).accept(new JetSignatureExceptionsAdapter() { - @Override - public JetSignatureVisitor visitFormalTypeParameter(String name, TypeInfoVariance variance, boolean reified) { - // TODO: collect - return new JetSignatureAdapter(); - } - - @Override - public JetSignatureVisitor visitSuperclass() { - return new JetTypeJetSignatureReader(semanticServices, KotlinBuiltIns.getInstance(), - typeVariableResolver) { - @Override - protected void done(@NotNull JetType jetType) { - if (!jetType.equals(KotlinBuiltIns.getInstance().getAnyType())) { - result.add(jetType); - } - } - }; - } - - @Override - public JetSignatureVisitor visitInterface() { - return visitSuperclass(); - } - }); - } - private void addBaseClass( @NotNull PsiClassWrapper psiClass, @NotNull ClassPsiDeclarationProvider classData, @@ -158,7 +105,7 @@ public final class JavaSupertypeResolver { else { //TODO: hack here result.add(KotlinBuiltIns.getInstance().getAnyType()); - // throw new IllegalStateException("Could not resolve java.lang.Object"); + // throw new IllegalStateException("Could not resolve java.lang.Object"); } } } 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 eb313a72a3a..7d832a99d09 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 @@ -22,8 +22,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiParameterWrapper; import org.jetbrains.jet.lang.resolve.name.Name; @@ -49,34 +49,17 @@ public final class JavaValueParameterResolver { PsiParameterWrapper parameter, TypeVariableResolver typeVariableResolver ) { - if (parameter.getJetTypeParameter().isDefined()) { - return JvmMethodParameterMeaning.typeInfo(); - } - PsiType psiType = parameter.getPsiParameter().getType(); // TODO: must be very slow, make it lazy? Name name = Name.identifier(getParameterName(i, parameter)); - if (parameter.getJetValueParameter().name().length() > 0) { - name = Name.identifier(parameter.getJetValueParameter().name()); - } - - String typeFromAnnotation = parameter.getJetValueParameter().type(); - boolean receiver = parameter.getJetValueParameter().receiver(); - boolean hasDefaultValue = parameter.getJetValueParameter().hasDefaultValue(); - - JetType outType; - if (typeFromAnnotation.length() > 0) { - outType = getTypeTransformer().transformToType(typeFromAnnotation, typeVariableResolver); - } - else { - TypeUsage typeUsage = JavaTypeTransformer.adjustTypeUsageWithMutabilityAnnotations(parameter.getPsiParameter(), TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT); - outType = getTypeTransformer().transformToType(psiType, typeUsage, typeVariableResolver); - } + TypeUsage typeUsage = JavaTypeTransformer + .adjustTypeUsageWithMutabilityAnnotations(parameter.getPsiParameter(), TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT); + JetType outType = getTypeTransformer().transformToType(psiType, typeUsage, typeVariableResolver); JetType varargElementType; - if (psiType instanceof PsiEllipsisType || parameter.getJetValueParameter().vararg()) { + if (psiType instanceof PsiEllipsisType) { varargElementType = KotlinBuiltIns.getInstance().getArrayElementType(TypeUtils.makeNotNullable(outType)); outType = TypeUtils.makeNotNullable(outType); } @@ -84,29 +67,24 @@ public final class JavaValueParameterResolver { varargElementType = null; } - if (receiver) { - return JvmMethodParameterMeaning.receiver(outType); + JetType transformedType; + if (JavaAnnotationResolver + .findAnnotationWithExternal(parameter.getPsiParameter(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) != + null) { + transformedType = TypeUtils.makeNullableAsSpecified(outType, false); } else { - - JetType transformedType; - if (JavaAnnotationResolver.findAnnotationWithExternal(parameter.getPsiParameter(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) != - null) { - transformedType = TypeUtils.makeNullableAsSpecified(outType, false); - } - else { - transformedType = outType; - } - return JvmMethodParameterMeaning.regular(new ValueParameterDescriptorImpl( - containingDeclaration, - i, - Collections.emptyList(), // TODO - name, - transformedType, - hasDefaultValue, - varargElementType - )); + transformedType = outType; } + return JvmMethodParameterMeaning.regular(new ValueParameterDescriptorImpl( + containingDeclaration, + i, + Collections.emptyList(), // TODO + name, + transformedType, + false, + varargElementType + )); } @NotNull @@ -182,9 +160,5 @@ public final class JavaValueParameterResolver { public static JvmMethodParameterMeaning regular(@NotNull ValueParameterDescriptor valueParameterDescriptor) { return new JvmMethodParameterMeaning(JvmMethodParameterKind.REGULAR, null, valueParameterDescriptor); } - - public static JvmMethodParameterMeaning typeInfo() { - return new JvmMethodParameterMeaning(JvmMethodParameterKind.TYPE_INFO, null, null); - } } } \ No newline at end of file diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java deleted file mode 100644 index 2b303038cd4..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * 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.scope; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; -import org.jetbrains.jet.lang.resolve.java.provider.KotlinNamespacePsiDeclarationProvider; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; - -import java.util.Collection; -import java.util.Set; - -public final class JavaScopeForKotlinNamespace extends JavaPackageScope { - @NotNull - private final KotlinNamespacePsiDeclarationProvider declarationProvider; - - public JavaScopeForKotlinNamespace( - @NotNull NamespaceDescriptor descriptor, - @NotNull KotlinNamespacePsiDeclarationProvider declarationProvider, - @NotNull FqName packageFQN, - @NotNull JavaSemanticServices semanticServices - ) { - super(descriptor, declarationProvider, packageFQN, semanticServices); - this.declarationProvider = declarationProvider; - } - - @NotNull - @Override - protected Set computeFunctionDescriptor(@NotNull Name name) { - return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor); - } - - @NotNull - @Override - protected Collection computeInnerClasses() { - return getResolver().resolveInnerClasses(declarationProvider); - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PropertyPsiDataElement.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PropertyPsiDataElement.java index e0067b602ee..e40f97dac95 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PropertyPsiDataElement.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PropertyPsiDataElement.java @@ -35,19 +35,6 @@ public final class PropertyPsiDataElement { private final TypeSource type; @Nullable private final TypeSource receiverType; - - - public PropertyPsiDataElement( - @NotNull PsiMethodWrapper method, - boolean getter, - @NotNull TypeSource type, - @Nullable TypeSource receiverType - ) { - this.member = method; - this.type = type; - this.receiverType = receiverType; - this.getter = getter; - } public PropertyPsiDataElement(@NotNull PsiFieldWrapper field, @NotNull TypeSource type, @Nullable TypeSource receiverType) { this.member = field; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiClassWrapper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiClassWrapper.java index 170c6022610..94f70045a48 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiClassWrapper.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiClassWrapper.java @@ -18,8 +18,6 @@ package org.jetbrains.jet.lang.resolve.java.wrapper; import com.intellij.psi.PsiClass; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; -import org.jetbrains.jet.lang.resolve.java.kt.JetPackageClassAnnotation; public class PsiClassWrapper { @@ -38,23 +36,4 @@ public class PsiClassWrapper { public PsiClass getPsiClass() { return psiClass; } - - private JetClassAnnotation jetClass; - private JetPackageClassAnnotation jetPackageClass; - - @NotNull - public JetClassAnnotation getJetClass() { - if (jetClass == null) { - jetClass = JetClassAnnotation.get(psiClass); - } - return jetClass; - } - - @NotNull - public JetPackageClassAnnotation getJetPackageClass() { - if (jetPackageClass == null) { - jetPackageClass = JetPackageClassAnnotation.get(psiClass); - } - return jetPackageClass; - } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMethodWrapper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMethodWrapper.java index 91333b3b80a..e8c66d2ea5d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMethodWrapper.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMethodWrapper.java @@ -22,8 +22,6 @@ import com.intellij.psi.PsiParameter; import com.intellij.psi.PsiType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.kt.JetConstructorAnnotation; -import org.jetbrains.jet.lang.resolve.java.kt.JetMethodAnnotation; import java.util.ArrayList; import java.util.List; @@ -33,8 +31,9 @@ public class PsiMethodWrapper extends PsiMemberWrapper { public PsiMethodWrapper(@NotNull PsiMethod psiMethod) { super(psiMethod); } - + private List parameters; + @NotNull public List getParameters() { if (parameters == null) { @@ -47,29 +46,6 @@ public class PsiMethodWrapper extends PsiMemberWrapper { return parameters; } - @NotNull - public PsiParameterWrapper getParameter(int i) { - return getParameters().get(i); - } - - private JetMethodAnnotation jetMethodAnnotation; - @NotNull - public JetMethodAnnotation getJetMethodAnnotation() { - if (jetMethodAnnotation == null) { - jetMethodAnnotation = JetMethodAnnotation.get(getPsiMethod()); - } - return jetMethodAnnotation; - } - - private JetConstructorAnnotation jetConstructorAnnotation; - @NotNull - public JetConstructorAnnotation getJetConstructorAnnotation() { - if (jetConstructorAnnotation == null) { - jetConstructorAnnotation = JetConstructorAnnotation.get(getPsiMethod()); - } - return jetConstructorAnnotation; - } - @Override public boolean isAbstract() { return psiMember.hasModifierProperty(PsiModifier.ABSTRACT); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiParameterWrapper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiParameterWrapper.java index 201092d51d9..60b75e9e62c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiParameterWrapper.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiParameterWrapper.java @@ -18,36 +18,16 @@ package org.jetbrains.jet.lang.resolve.java.wrapper; import com.intellij.psi.PsiParameter; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.java.kt.JetTypeParameterAnnotation; -import org.jetbrains.jet.lang.resolve.java.kt.JetValueParameterAnnotation; public class PsiParameterWrapper { private final PsiParameter psiParameter; public PsiParameterWrapper(@NotNull PsiParameter psiParameter) { this.psiParameter = psiParameter; - - this.jetValueParameter = JetValueParameterAnnotation.get(psiParameter); - this.jetTypeParameter = JetTypeParameterAnnotation.get(psiParameter); } - @NotNull - private final JetValueParameterAnnotation jetValueParameter; - @NotNull - private final JetTypeParameterAnnotation jetTypeParameter; - @NotNull public PsiParameter getPsiParameter() { return psiParameter; } - - @NotNull - public JetValueParameterAnnotation getJetValueParameter() { - return jetValueParameter; - } - - @NotNull - public JetTypeParameterAnnotation getJetTypeParameter() { - return jetTypeParameter; - } }