Drop PsiBasedMethodSignatureChecker

2015-06-05 20:21:06 +03:00
parent 12d7187394
commit d4c18b3d55
11 changed files with 31 additions and 369 deletions
@@ -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);
@@ -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);
@@ -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);
@@ -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<TypeSubstitution> substitutions = new ArrayList<TypeSubstitution>();
-        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<FunctionDescriptor> 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<HierarchicalMethodSignature> 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<String> signatureErrors,
-            @NotNull List<FunctionDescriptor> 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 extends Foo> 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() {
-        }
-    }
-}
@@ -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<String> signatureErrors,
-                @NotNull List<FunctionDescriptor> superFunctions
-        ) {
-        }
-    };
-
-    void checkSignature(
-            @NotNull JavaMethod method,
-            boolean reportSignatureErrors,
-            @NotNull SimpleFunctionDescriptor descriptor,
-            @NotNull List<String> signatureErrors,
-            @NotNull List<FunctionDescriptor> superFunctions
-    );
-}
@@ -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,
@@ -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 {
@@ -98,7 +98,6 @@ public abstract class LazyJavaMemberScope(

    protected data class MethodSignatureData(
            val effectiveSignature: ExternalSignatureResolver.AlternativeMethodSignature,
-            val superFunctions: List<FunctionDescriptor>,
            val errors: List<String>
    )

@@ -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
    }
@@ -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<PropertyDescriptor>) {
@@ -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());
@@ -133,7 +133,6 @@ private fun generatorForRuntimeDescriptorLoader() =
            publicField<DeserializationComponentsForJava>()

            field<ExternalSignatureResolver>(init = GetSingleton.byField(javaClass<ExternalSignatureResolver>(), "DO_NOTHING"))
-            field<MethodSignatureChecker>(init = GetSingleton.byField(javaClass<MethodSignatureChecker>(), "DO_NOTHING"))
            field<JavaResolverCache>(init = GetSingleton.byField(javaClass<JavaResolverCache>(), "EMPTY"))
            field<ExternalAnnotationResolver>(init = GetSingleton.byField(javaClass<ExternalAnnotationResolver>(), "EMPTY"))
            field<JavaPropertyInitializerEvaluator>(init = GetSingleton.byField(javaClass<JavaPropertyInitializerEvaluator>(), "DO_NOTHING"))
@@ -165,7 +164,6 @@ private fun generatorForLazyResolveWithJava() =
            field<TraceBasedExternalSignatureResolver>()
            field<LazyResolveBasedCache>()
            field<TraceBasedErrorReporter>()
-            field<PsiBasedMethodSignatureChecker>()
            field<PsiBasedExternalAnnotationResolver>()
            field<JavaPropertyInitializerEvaluatorImpl>()
            field<SamConversionResolverImpl>()
@@ -268,7 +266,6 @@ private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() {
    field<TraceBasedExternalSignatureResolver>()
    field<LazyResolveBasedCache>()
    field<TraceBasedErrorReporter>()
-    field<PsiBasedMethodSignatureChecker>()
    field<PsiBasedExternalAnnotationResolver>()
    field<JavaPropertyInitializerEvaluatorImpl>()
    field<SamConversionResolverImpl>()