From d4c18b3d554d5b5d54d4fd05d79244eae30a1490 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 5 Jun 2015 20:21:06 +0300 Subject: [PATCH] Drop PsiBasedMethodSignatureChecker --- .../di/InjectorForLazyResolveWithJava.java | 8 +- .../kotlin/di/InjectorForReplWithJava.java | 8 +- .../di/InjectorForTopDownAnalyzerForJvm.java | 8 +- .../PsiBasedMethodSignatureChecker.java | 274 ------------------ .../components/MethodSignatureChecker.java | 46 --- .../kotlin/load/java/lazy/context.kt | 19 +- .../descriptors/LazyJavaClassMemberScope.kt | 11 +- .../lazy/descriptors/LazyJavaMemberScope.kt | 8 +- .../lazy/descriptors/LazyJavaStaticScope.kt | 10 +- .../InjectorForRuntimeDescriptorLoader.java | 5 +- .../generators/injectors/GenerateInjectors.kt | 3 - 11 files changed, 31 insertions(+), 369 deletions(-) delete mode 100644 compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/PsiBasedMethodSignatureChecker.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/MethodSignatureChecker.java diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java index c7de7152aa5..0e703be7c4a 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java @@ -34,7 +34,6 @@ import org.jetbrains.kotlin.load.java.JavaClassFinderImpl; import org.jetbrains.kotlin.load.java.components.TraceBasedExternalSignatureResolver; import org.jetbrains.kotlin.load.java.components.LazyResolveBasedCache; import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter; -import org.jetbrains.kotlin.load.java.components.PsiBasedMethodSignatureChecker; import org.jetbrains.kotlin.load.java.components.PsiBasedExternalAnnotationResolver; import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl; import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl; @@ -103,7 +102,6 @@ public class InjectorForLazyResolveWithJava { private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver; private final LazyResolveBasedCache lazyResolveBasedCache; private final TraceBasedErrorReporter traceBasedErrorReporter; - private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker; private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver; private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator; private final SamConversionResolverImpl samConversionResolver; @@ -173,12 +171,11 @@ public class InjectorForLazyResolveWithJava { this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(traceBasedErrorReporter); this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver(); this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver(); - this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker(); this.lazyResolveBasedCache = new LazyResolveBasedCache(); this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl(); this.samConversionResolver = SamConversionResolverImpl.INSTANCE$; this.javaSourceElementFactory = new JavaSourceElementFactoryImpl(); - this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, jvmVirtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, moduleClassResolver); + this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, jvmVirtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, moduleClassResolver); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, moduleDescriptor, reflectionTypes); this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, moduleDescriptor); @@ -243,9 +240,6 @@ public class InjectorForLazyResolveWithJava { traceBasedErrorReporter.setTrace(bindingTrace); - psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); - psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver); - javaLazyAnalyzerPostConstruct.setCodeAnalyzer(resolveSession); javaLazyAnalyzerPostConstruct.setProject(project); javaLazyAnalyzerPostConstruct.setTrace(bindingTrace); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java index 77e0b51fedd..399289b0476 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java @@ -36,7 +36,6 @@ import org.jetbrains.kotlin.load.java.JavaClassFinderImpl; import org.jetbrains.kotlin.load.java.components.TraceBasedExternalSignatureResolver; import org.jetbrains.kotlin.load.java.components.LazyResolveBasedCache; import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter; -import org.jetbrains.kotlin.load.java.components.PsiBasedMethodSignatureChecker; import org.jetbrains.kotlin.load.java.components.PsiBasedExternalAnnotationResolver; import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl; import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl; @@ -116,7 +115,6 @@ public class InjectorForReplWithJava { private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver; private final LazyResolveBasedCache lazyResolveBasedCache; private final TraceBasedErrorReporter traceBasedErrorReporter; - private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker; private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver; private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator; private final SamConversionResolverImpl samConversionResolver; @@ -196,13 +194,12 @@ public class InjectorForReplWithJava { this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(traceBasedErrorReporter); this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver(); this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver(); - this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker(); this.lazyResolveBasedCache = new LazyResolveBasedCache(); this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl(); this.samConversionResolver = SamConversionResolverImpl.INSTANCE$; this.javaSourceElementFactory = new JavaSourceElementFactoryImpl(); this.singleModuleClassResolver = new SingleModuleClassResolver(); - this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, jvmVirtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver); + this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, jvmVirtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, moduleDescriptor, reflectionTypes); this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, moduleDescriptor); @@ -291,9 +288,6 @@ public class InjectorForReplWithJava { traceBasedErrorReporter.setTrace(bindingTrace); - psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); - psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver); - singleModuleClassResolver.setResolver(javaDescriptorResolver); javaLazyAnalyzerPostConstruct.setCodeAnalyzer(resolveSession); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java index aa685e695c4..70c33ba7a82 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java @@ -36,7 +36,6 @@ import org.jetbrains.kotlin.load.java.JavaClassFinderImpl; import org.jetbrains.kotlin.load.java.components.TraceBasedExternalSignatureResolver; import org.jetbrains.kotlin.load.java.components.LazyResolveBasedCache; import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter; -import org.jetbrains.kotlin.load.java.components.PsiBasedMethodSignatureChecker; import org.jetbrains.kotlin.load.java.components.PsiBasedExternalAnnotationResolver; import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl; import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl; @@ -116,7 +115,6 @@ public class InjectorForTopDownAnalyzerForJvm { private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver; private final LazyResolveBasedCache lazyResolveBasedCache; private final TraceBasedErrorReporter traceBasedErrorReporter; - private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker; private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver; private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator; private final SamConversionResolverImpl samConversionResolver; @@ -195,13 +193,12 @@ public class InjectorForTopDownAnalyzerForJvm { this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(traceBasedErrorReporter); this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver(); this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver(); - this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker(); this.lazyResolveBasedCache = new LazyResolveBasedCache(); this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl(); this.samConversionResolver = SamConversionResolverImpl.INSTANCE$; this.javaSourceElementFactory = new JavaSourceElementFactoryImpl(); this.singleModuleClassResolver = new SingleModuleClassResolver(); - this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, jvmVirtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver); + this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, jvmVirtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, moduleDescriptor, reflectionTypes); this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, moduleDescriptor); @@ -290,9 +287,6 @@ public class InjectorForTopDownAnalyzerForJvm { traceBasedErrorReporter.setTrace(bindingTrace); - psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); - psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver); - singleModuleClassResolver.setResolver(javaDescriptorResolver); javaLazyAnalyzerPostConstruct.setCodeAnalyzer(resolveSession); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/PsiBasedMethodSignatureChecker.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/PsiBasedMethodSignatureChecker.java deleted file mode 100644 index 5edf6f0b8a4..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/PsiBasedMethodSignatureChecker.java +++ /dev/null @@ -1,274 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.load.java.components; - -import com.intellij.openapi.diagnostic.Logger; -import com.intellij.psi.*; -import com.intellij.psi.util.MethodSignatureBackedByPsiMethod; -import com.intellij.psi.util.MethodSignatureUtil; -import com.intellij.psi.util.PsiUtil; -import com.intellij.psi.util.TypeConversionUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.descriptors.ClassDescriptor; -import org.jetbrains.kotlin.descriptors.FunctionDescriptor; -import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor; -import org.jetbrains.kotlin.load.java.structure.*; -import org.jetbrains.kotlin.load.java.structure.impl.JavaMethodImpl; -import org.jetbrains.kotlin.resolve.OverrideResolver; -import org.jetbrains.kotlin.resolve.OverridingUtil; -import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.SignaturesUtil; -import org.jetbrains.kotlin.types.ErrorUtils; -import org.jetbrains.kotlin.types.SubstitutionUtils; -import org.jetbrains.kotlin.types.TypeSubstitution; -import org.jetbrains.kotlin.types.TypeSubstitutor; - -import javax.inject.Inject; -import java.util.ArrayList; -import java.util.List; - -public class PsiBasedMethodSignatureChecker implements MethodSignatureChecker { - private static final Logger LOG = Logger.getInstance(PsiBasedMethodSignatureChecker.class); - - private ExternalAnnotationResolver externalAnnotationResolver; - private ExternalSignatureResolver externalSignatureResolver; - - @Inject - public void setExternalAnnotationResolver(ExternalAnnotationResolver externalAnnotationResolver) { - this.externalAnnotationResolver = externalAnnotationResolver; - } - - @Inject - public void setExternalSignatureResolver(ExternalSignatureResolver externalSignatureResolver) { - this.externalSignatureResolver = externalSignatureResolver; - } - - private void checkFunctionOverridesCorrectly( - @NotNull JavaMethod method, - @NotNull FunctionDescriptor function, - @NotNull FunctionDescriptor superFunction - ) { - ClassDescriptor klass = (ClassDescriptor) function.getContainingDeclaration(); - List substitutions = new ArrayList(); - while (true) { - substitutions.add(SubstitutionUtils.buildDeepSubstitutor(klass.getDefaultType()).getSubstitution()); - if (!klass.isInner()) { - break; - } - klass = (ClassDescriptor) klass.getContainingDeclaration(); - } - TypeSubstitutor substitutor = TypeSubstitutor.create(substitutions.toArray(new TypeSubstitution[substitutions.size()])); - FunctionDescriptor superFunctionSubstituted = superFunction.substitute(substitutor); - - assert superFunctionSubstituted != null : "Couldn't substitute super function: " + superFunction + ", substitutor = " + substitutor; - - OverridingUtil.OverrideCompatibilityInfo.Result overridableResult = OverridingUtil.DEFAULT.isOverridableBy(superFunctionSubstituted, function).getResult(); - boolean paramsOk = overridableResult == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE; - boolean returnTypeOk = OverrideResolver.isReturnTypeOkForOverride(superFunctionSubstituted, function); - if (!paramsOk || !returnTypeOk) { - // This should be a LOG.error, but happens a lot of times incorrectly (e.g. on Kotlin project), because somewhere in the - // type checker we compare two types which seem the same but have different instances of class descriptors. It happens - // probably because JavaDescriptorResolver is not completely thread-safe yet, and one class gets resolved multiple times. - // TODO: change to LOG.error when JavaDescriptorResolver becomes thread-safe - LOG.warn("Loaded Java method overrides another, but resolved as Kotlin function, doesn't.\n" - + "super function = " + superFunction + "\n" - + "super class = " + superFunction.getContainingDeclaration() + "\n" - + "sub function = " + function + "\n" - + "sub class = " + function.getContainingDeclaration() + "\n" - + "sub method = " + method + "\n" - + "@KotlinSignature = " + SignaturesUtil.getKotlinSignature(externalAnnotationResolver, method)); - } - } - - private static boolean containsErrorType(@NotNull List superFunctions, @NotNull FunctionDescriptor function) { - if (ErrorUtils.containsErrorType(function)) { - return true; - } - - for (FunctionDescriptor superFunction : superFunctions) { - if (ErrorUtils.containsErrorType(superFunction)) { - return true; - } - } - - return false; - } - - // Originally from com.intellij.codeInsight.daemon.impl.analysis.HighlightMethodUtil - private static boolean isMethodReturnTypeCompatible(@NotNull JavaMethodImpl method) { - if (method.isStatic()) return true; - - HierarchicalMethodSignature methodSignature = method.getPsi().getHierarchicalMethodSignature(); - List superSignatures = methodSignature.getSuperSignatures(); - - PsiType returnType = methodSignature.getSubstitutor().substitute(method.getPsi().getReturnType()); - if (returnType == null) return true; - - for (MethodSignatureBackedByPsiMethod superMethodSignature : superSignatures) { - PsiMethod superMethod = superMethodSignature.getMethod(); - PsiType declaredReturnType = superMethod.getReturnType(); - PsiType superReturnType = superMethodSignature.isRaw() ? TypeConversionUtil.erasure(declaredReturnType) : declaredReturnType; - if (superReturnType == null || method == superMethod || superMethod.getContainingClass() == null) continue; - if (!areMethodsReturnTypesCompatible(superMethodSignature, superReturnType, methodSignature, returnType)) { - return false; - } - } - - return true; - } - - // Originally from com.intellij.codeInsight.daemon.impl.analysis.HighlightMethodUtil - private static boolean areMethodsReturnTypesCompatible( - @NotNull MethodSignatureBackedByPsiMethod superMethodSignature, - @NotNull PsiType superReturnType, - @NotNull MethodSignatureBackedByPsiMethod methodSignature, - @NotNull PsiType returnType - ) { - PsiType substitutedSuperReturnType; - boolean isJdk15 = PsiUtil.isLanguageLevel5OrHigher(methodSignature.getMethod()); - if (isJdk15 && !superMethodSignature.isRaw() && superMethodSignature.equals(methodSignature)) { //see 8.4.5 - PsiSubstitutor unifyingSubstitutor = MethodSignatureUtil.getSuperMethodSignatureSubstitutor(methodSignature, - superMethodSignature); - substitutedSuperReturnType = unifyingSubstitutor == null - ? superReturnType - : unifyingSubstitutor.substitute(superReturnType); - } - else { - substitutedSuperReturnType = TypeConversionUtil.erasure(superMethodSignature.getSubstitutor().substitute(superReturnType)); - } - - if (returnType.equals(substitutedSuperReturnType)) return true; - if (!(returnType instanceof PsiPrimitiveType) && substitutedSuperReturnType.getDeepComponentType() instanceof PsiClassType) { - if (isJdk15 && TypeConversionUtil.isAssignable(substitutedSuperReturnType, returnType)) { - return true; - } - } - - return false; - } - - @Override - public void checkSignature( - @NotNull JavaMethod method, - boolean reportSignatureErrors, - @NotNull SimpleFunctionDescriptor descriptor, - @NotNull List signatureErrors, - @NotNull List superFunctions - ) { - // This optimization speed things up because hasRawTypesInHierarchicalSignature() is very expensive - if (superFunctions.isEmpty() && (signatureErrors.isEmpty() || !reportSignatureErrors)) return; - - JavaMethodImpl methodWithPsi = (JavaMethodImpl) method; - if (!RawTypesCheck.hasRawTypesInHierarchicalSignature(methodWithPsi) && - isMethodReturnTypeCompatible(methodWithPsi) && - !containsErrorType(superFunctions, descriptor)) { - if (signatureErrors.isEmpty()) { - for (FunctionDescriptor superFunction : superFunctions) { - checkFunctionOverridesCorrectly(method, descriptor, superFunction); - } - } - else if (reportSignatureErrors) { - externalSignatureResolver.reportSignatureErrors(descriptor, signatureErrors); - } - } - } - - private static class RawTypesCheck { - private static boolean isPartiallyRawType(@NotNull JavaType type) { - if (type instanceof JavaPrimitiveType) { - return false; - } - else if (type instanceof JavaClassifierType) { - JavaClassifierType classifierType = (JavaClassifierType) type; - - if (classifierType.isRaw()) { - return true; - } - - for (JavaType argument : classifierType.getTypeArguments()) { - if (isPartiallyRawType(argument)) { - return true; - } - } - - return false; - } - else if (type instanceof JavaArrayType) { - return isPartiallyRawType(((JavaArrayType) type).getComponentType()); - } - else if (type instanceof JavaWildcardType) { - JavaType bound = ((JavaWildcardType) type).getBound(); - return bound != null && isPartiallyRawType(bound); - } - else { - throw new IllegalStateException("Unexpected type: " + type); - } - } - - private static boolean hasRawTypesInSignature(@NotNull JavaMethod method) { - JavaType returnType = method.getReturnType(); - if (returnType != null && isPartiallyRawType(returnType)) { - return true; - } - - for (JavaValueParameter parameter : method.getValueParameters()) { - if (isPartiallyRawType(parameter.getType())) { - return true; - } - } - - for (JavaTypeParameter typeParameter : method.getTypeParameters()) { - for (JavaClassifierType upperBound : typeParameter.getUpperBounds()) { - if (isPartiallyRawType(upperBound)) { - return true; - } - } - } - - return false; - } - - public static boolean hasRawTypesInHierarchicalSignature(@NotNull JavaMethodImpl method) { - // This is a very important optimization: package-classes are big and full of static methods - // building method hierarchies for such classes takes a very long time - if (method.isStatic()) return false; - - if (hasRawTypesInSignature(method)) { - return true; - } - - for (HierarchicalMethodSignature superSignature : method.getPsi().getHierarchicalMethodSignature().getSuperSignatures()) { - JavaMethod superMethod = new JavaMethodImpl(superSignature.getMethod()); - if (superSignature.isRaw() || typeParameterIsErased(method, superMethod) || hasRawTypesInSignature(superMethod)) { - return true; - } - } - - return false; - } - - private static boolean typeParameterIsErased(@NotNull JavaMethod method, @NotNull JavaMethod superMethod) { - // Java allows you to write - // T foo(), in the superclass and then - // Foo foo(), in the subclass - // this is a valid Java override, but in fact it is an erasure - return method.getTypeParameters().size() != superMethod.getTypeParameters().size(); - } - - private RawTypesCheck() { - } - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/MethodSignatureChecker.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/MethodSignatureChecker.java deleted file mode 100644 index 60ef7f6ebbd..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/MethodSignatureChecker.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.load.java.components; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.descriptors.FunctionDescriptor; -import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor; -import org.jetbrains.kotlin.load.java.structure.JavaMethod; - -import java.util.List; - -public interface MethodSignatureChecker { - MethodSignatureChecker DO_NOTHING = new MethodSignatureChecker() { - @Override - public void checkSignature( - @NotNull JavaMethod method, - boolean reportSignatureErrors, - @NotNull SimpleFunctionDescriptor descriptor, - @NotNull List signatureErrors, - @NotNull List superFunctions - ) { - } - }; - - void checkSignature( - @NotNull JavaMethod method, - boolean reportSignatureErrors, - @NotNull SimpleFunctionDescriptor descriptor, - @NotNull List signatureErrors, - @NotNull List superFunctions - ); -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/context.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/context.kt index d0ff5a9677c..7d4f00359ad 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/context.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/context.kt @@ -17,18 +17,21 @@ package org.jetbrains.kotlin.load.java.lazy import org.jetbrains.kotlin.builtins.ReflectionTypes -import org.jetbrains.kotlin.storage.StorageManager -import org.jetbrains.kotlin.load.java.lazy.types.LazyJavaTypeResolver import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.load.java.JavaClassFinder -import org.jetbrains.kotlin.load.java.components.* +import org.jetbrains.kotlin.load.java.components.ExternalAnnotationResolver +import org.jetbrains.kotlin.load.java.components.ExternalSignatureResolver +import org.jetbrains.kotlin.load.java.components.JavaResolverCache +import org.jetbrains.kotlin.load.java.components.SamConversionResolver +import org.jetbrains.kotlin.load.java.lazy.types.LazyJavaTypeResolver +import org.jetbrains.kotlin.load.java.sources.JavaSourceElementFactory +import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator +import org.jetbrains.kotlin.load.java.structure.JavaTypeParameterListOwner import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder -import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator -import org.jetbrains.kotlin.load.java.sources.JavaSourceElementFactory -import org.jetbrains.kotlin.load.java.structure.JavaTypeParameterListOwner -import org.jetbrains.kotlin.serialization.deserialization.* +import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter +import org.jetbrains.kotlin.storage.StorageManager open class GlobalJavaResolverContext( val storageManager: StorageManager, @@ -38,7 +41,6 @@ open class GlobalJavaResolverContext( val externalAnnotationResolver: ExternalAnnotationResolver, val externalSignatureResolver: ExternalSignatureResolver, val errorReporter: ErrorReporter, - val methodSignatureChecker: MethodSignatureChecker, val javaResolverCache: JavaResolverCache, val javaPropertyInitializerEvaluator: JavaPropertyInitializerEvaluator, val samConversionResolver: SamConversionResolver, @@ -61,7 +63,6 @@ open class LazyJavaResolverContext( globalContext.externalAnnotationResolver, globalContext.externalSignatureResolver, globalContext.errorReporter, - globalContext.methodSignatureChecker, globalContext.javaResolverCache, globalContext.javaPropertyInitializerEvaluator, globalContext.samConversionResolver, diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt index 7440c2787fd..9b89af61079 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt @@ -125,14 +125,15 @@ public class LazyJavaClassMemberScope( valueParameters: LazyJavaMemberScope.ResolvedValueParameters ): LazyJavaMemberScope.MethodSignatureData { val propagated = c.externalSignatureResolver.resolvePropagatedSignature( - method, getContainingDeclaration(), returnType, null, valueParameters.descriptors, methodTypeParameters) - val superFunctions = propagated.getSuperMethods() + method, getContainingDeclaration(), returnType, null, valueParameters.descriptors, methodTypeParameters + ) val effectiveSignature = c.externalSignatureResolver.resolveAlternativeMethodSignature( - method, !superFunctions.isEmpty(), propagated.getReturnType(), + method, !propagated.getSuperMethods().isEmpty(), propagated.getReturnType(), propagated.getReceiverType(), propagated.getValueParameters(), propagated.getTypeParameters(), - propagated.hasStableParameterNames()) + propagated.hasStableParameterNames() + ) - return LazyJavaMemberScope.MethodSignatureData(effectiveSignature, superFunctions, propagated.getErrors() + effectiveSignature.getErrors()) + return LazyJavaMemberScope.MethodSignatureData(effectiveSignature, propagated.getErrors() + effectiveSignature.getErrors()) } private fun resolveConstructor(constructor: JavaConstructor): JavaConstructorDescriptor { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaMemberScope.kt index 42c4f0fce2d..556890a9074 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaMemberScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaMemberScope.kt @@ -98,7 +98,6 @@ public abstract class LazyJavaMemberScope( protected data class MethodSignatureData( val effectiveSignature: ExternalSignatureResolver.AlternativeMethodSignature, - val superFunctions: List, val errors: List ) @@ -109,7 +108,6 @@ public abstract class LazyJavaMemberScope( valueParameters: ResolvedValueParameters): MethodSignatureData fun resolveMethodToFunctionDescriptor(method: JavaMethod, record: Boolean = true): JavaMethodDescriptor { - val annotations = c.resolveAnnotations(method) val functionDescriptorImpl = JavaMethodDescriptor.createJavaMethod( containingDeclaration, annotations, method.getName(), c.sourceElementFactory.source(method) @@ -122,7 +120,7 @@ public abstract class LazyJavaMemberScope( val returnType = computeMethodReturnType(method, annotations, c) - val (effectiveSignature, superFunctions, signatureErrors) = resolveMethodSignature(method, methodTypeParameters, returnType, valueParameters) + val (effectiveSignature, signatureErrors) = resolveMethodSignature(method, methodTypeParameters, returnType, valueParameters) functionDescriptorImpl.initialize( effectiveSignature.getReceiverType(), @@ -141,7 +139,9 @@ public abstract class LazyJavaMemberScope( c.javaResolverCache.recordMethod(method, functionDescriptorImpl) } - c.methodSignatureChecker.checkSignature(method, record, functionDescriptorImpl, signatureErrors, superFunctions) + if (signatureErrors.isNotEmpty()) { + c.externalSignatureResolver.reportSignatureErrors(functionDescriptorImpl, signatureErrors) + } return functionDescriptorImpl } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticScope.kt index 618647440a9..eb3c02bd11e 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticScope.kt @@ -16,10 +16,14 @@ package org.jetbrains.kotlin.load.java.lazy.descriptors -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.name.* +import org.jetbrains.kotlin.descriptors.ClassOrPackageFragmentDescriptor +import org.jetbrains.kotlin.descriptors.PropertyDescriptor +import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor +import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext import org.jetbrains.kotlin.load.java.structure.JavaMethod +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.JetType public abstract class LazyJavaStaticScope( @@ -41,7 +45,7 @@ public abstract class LazyJavaStaticScope( ): LazyJavaMemberScope.MethodSignatureData { val effectiveSignature = c.externalSignatureResolver.resolveAlternativeMethodSignature( method, false, returnType, null, valueParameters.descriptors, methodTypeParameters, false) - return LazyJavaMemberScope.MethodSignatureData(effectiveSignature, listOf(), effectiveSignature.getErrors()) + return LazyJavaMemberScope.MethodSignatureData(effectiveSignature, effectiveSignature.getErrors()) } override fun computeNonDeclaredProperties(name: Name, result: MutableCollection) { diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java b/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java index 685a1cc6a5f..7d085cae3f7 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.storage.StorageManager; import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver; import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava; import org.jetbrains.kotlin.load.java.components.ExternalSignatureResolver; -import org.jetbrains.kotlin.load.java.components.MethodSignatureChecker; import org.jetbrains.kotlin.load.java.components.JavaResolverCache; import org.jetbrains.kotlin.load.java.components.ExternalAnnotationResolver; import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator; @@ -50,7 +49,6 @@ public class InjectorForRuntimeDescriptorLoader { private final JavaDescriptorResolver javaDescriptorResolver; private final DeserializationComponentsForJava deserializationComponentsForJava; private final ExternalSignatureResolver externalSignatureResolver; - private final MethodSignatureChecker methodSignatureChecker; private final JavaResolverCache javaResolverCache; private final ExternalAnnotationResolver externalAnnotationResolver; private final JavaPropertyInitializerEvaluator javaPropertyInitializerEvaluator; @@ -81,13 +79,12 @@ public class InjectorForRuntimeDescriptorLoader { this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(runtimeErrorReporter); this.externalAnnotationResolver = ExternalAnnotationResolver.EMPTY; this.externalSignatureResolver = ExternalSignatureResolver.DO_NOTHING; - this.methodSignatureChecker = MethodSignatureChecker.DO_NOTHING; this.javaResolverCache = JavaResolverCache.EMPTY; this.javaPropertyInitializerEvaluator = JavaPropertyInitializerEvaluator.DO_NOTHING; this.samConversionResolver = SamConversionResolver.EMPTY; this.runtimeSourceElementFactory = RuntimeSourceElementFactory.INSTANCE$; this.singleModuleClassResolver = new SingleModuleClassResolver(); - this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, reflectJavaClassFinder, reflectKotlinClassFinder, deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, runtimeErrorReporter, methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, runtimeSourceElementFactory, singleModuleClassResolver); + this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, reflectJavaClassFinder, reflectKotlinClassFinder, deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, runtimeErrorReporter, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, runtimeSourceElementFactory, singleModuleClassResolver); this.reflectionTypes = new ReflectionTypes(getModuleDescriptor()); this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor(), reflectionTypes); this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModuleDescriptor()); diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index 1838759c027..f0f381299eb 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -133,7 +133,6 @@ private fun generatorForRuntimeDescriptorLoader() = publicField() field(init = GetSingleton.byField(javaClass(), "DO_NOTHING")) - field(init = GetSingleton.byField(javaClass(), "DO_NOTHING")) field(init = GetSingleton.byField(javaClass(), "EMPTY")) field(init = GetSingleton.byField(javaClass(), "EMPTY")) field(init = GetSingleton.byField(javaClass(), "DO_NOTHING")) @@ -165,7 +164,6 @@ private fun generatorForLazyResolveWithJava() = field() field() field() - field() field() field() field() @@ -268,7 +266,6 @@ private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() { field() field() field() - field() field() field() field()