diff --git a/python/src/com/jetbrains/python/inspections/PyOverloadsInspection.kt b/python/src/com/jetbrains/python/inspections/PyOverloadsInspection.kt index 04a1c9a969f3..e1e521c2dbda 100644 --- a/python/src/com/jetbrains/python/inspections/PyOverloadsInspection.kt +++ b/python/src/com/jetbrains/python/inspections/PyOverloadsInspection.kt @@ -26,7 +26,7 @@ import com.jetbrains.python.psi.PyFile import com.jetbrains.python.psi.PyFunction import com.jetbrains.python.psi.PyUtil import com.jetbrains.python.pyi.PyiFile -import com.jetbrains.python.pyi.PyiTypeProvider +import com.jetbrains.python.pyi.PyiUtil import java.util.* class PyOverloadsInspection : PyInspection() { @@ -64,9 +64,9 @@ class PyOverloadsInspection : PyInspection() { } private fun processSameNameFunctions(owner: ScopeOwner, functions: List) { - if (functions.find { PyiTypeProvider.isOverload(it, myTypeEvalContext) } == null) return + if (functions.find { PyiUtil.isOverload(it, myTypeEvalContext) } == null) return - val implementation = functions.lastOrNull { !PyiTypeProvider.isOverload(it, myTypeEvalContext) } + val implementation = functions.lastOrNull { !PyiUtil.isOverload(it, myTypeEvalContext) } if (implementation == null) { functions @@ -101,7 +101,7 @@ class PyOverloadsInspection : PyInspection() { private fun isIncompatibleOverload(implementation: PyFunction, overload: PyFunction): Boolean { return implementation != overload && - PyiTypeProvider.isOverload(overload, myTypeEvalContext) && + PyiUtil.isOverload(overload, myTypeEvalContext) && !PyUtil.isSignatureCompatibleTo(implementation, overload, myTypeEvalContext) } } diff --git a/python/src/com/jetbrains/python/inspections/PyRedeclarationInspection.java b/python/src/com/jetbrains/python/inspections/PyRedeclarationInspection.java index c4650af37439..7f9d3946aeee 100644 --- a/python/src/com/jetbrains/python/inspections/PyRedeclarationInspection.java +++ b/python/src/com/jetbrains/python/inspections/PyRedeclarationInspection.java @@ -34,7 +34,7 @@ import com.jetbrains.python.codeInsight.controlflow.ScopeOwner; import com.jetbrains.python.codeInsight.dataflow.scope.ScopeUtil; import com.jetbrains.python.inspections.quickfix.PyRenameElementQuickFix; import com.jetbrains.python.psi.*; -import com.jetbrains.python.pyi.PyiTypeProvider; +import com.jetbrains.python.pyi.PyiUtil; import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -138,7 +138,7 @@ public class PyRedeclarationInspection extends PyInspection { readElementRef.set(originalElement); } if (rwInstruction.getAccess().isWriteAccess() && originalElement != element) { - if (element instanceof PyCallable && isOverload(originalElement)) { + if (PyiUtil.isOverload(originalElement, myTypeEvalContext)) { return ControlFlowUtil.Operation.NEXT; } else { @@ -167,10 +167,6 @@ public class PyRedeclarationInspection extends PyInspection { } } - private boolean isOverload(@NotNull PsiElement element) { - return element instanceof PyCallable && PyiTypeProvider.isOverload((PyCallable)element, myTypeEvalContext); - } - private static boolean suggestRename(@NotNull PsiNameIdentifierOwner element, @NotNull PsiElement originalElement) { // Target expressions in the same scope are treated as the same variable if ((element instanceof PyTargetExpression) && originalElement instanceof PyTargetExpression) { diff --git a/python/src/com/jetbrains/python/inspections/PyUnusedLocalInspectionVisitor.java b/python/src/com/jetbrains/python/inspections/PyUnusedLocalInspectionVisitor.java index bb0f6c139b88..28c16ce42d42 100644 --- a/python/src/com/jetbrains/python/inspections/PyUnusedLocalInspectionVisitor.java +++ b/python/src/com/jetbrains/python/inspections/PyUnusedLocalInspectionVisitor.java @@ -46,7 +46,7 @@ import com.jetbrains.python.psi.impl.PyImportStatementNavigator; import com.jetbrains.python.psi.resolve.PyResolveContext; import com.jetbrains.python.psi.search.PyOverridingMethodsSearch; import com.jetbrains.python.psi.search.PySuperMethodsSearch; -import com.jetbrains.python.pyi.PyiTypeProvider; +import com.jetbrains.python.pyi.PyiUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -79,7 +79,7 @@ public class PyUnusedLocalInspectionVisitor extends PyInspectionVisitor { @Override public void visitPyFunction(final PyFunction node) { - if (!PyiTypeProvider.isOverload(node, myTypeEvalContext)) { + if (!PyiUtil.isOverload(node, myTypeEvalContext)) { processScope(node); } } @@ -451,12 +451,14 @@ public class PyUnusedLocalInspectionVisitor extends PyInspectionVisitor { } private static class ReplaceWithWildCard implements LocalQuickFix { + @Override @NotNull public String getFamilyName() { return PyBundle.message("INSP.unused.locals.replace.with.wildcard"); } - public void applyFix(@NotNull final Project project, @NotNull final ProblemDescriptor descriptor) { + @Override + public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { PsiElement psiElement = descriptor.getPsiElement(); final PyFile pyFile = (PyFile) PyElementGenerator.getInstance(psiElement.getProject()).createDummyFile(LanguageLevel.getDefault(), "for _ in tuples:\n pass" diff --git a/python/src/com/jetbrains/python/inspections/quickfix/PyRemoveParameterQuickFix.java b/python/src/com/jetbrains/python/inspections/quickfix/PyRemoveParameterQuickFix.java index c01a2cd881d7..c1137abf4ef7 100644 --- a/python/src/com/jetbrains/python/inspections/quickfix/PyRemoveParameterQuickFix.java +++ b/python/src/com/jetbrains/python/inspections/quickfix/PyRemoveParameterQuickFix.java @@ -30,7 +30,7 @@ import com.jetbrains.python.psi.PyParameter; import com.jetbrains.python.psi.PyStringLiteralExpression; import com.jetbrains.python.psi.resolve.PyResolveContext; import com.jetbrains.python.psi.types.TypeEvalContext; -import com.jetbrains.python.pyi.PyiTypeProvider; +import com.jetbrains.python.pyi.PyiUtil; import com.jetbrains.python.refactoring.PyRefactoringUtil; import one.util.streamex.StreamEx; import org.jetbrains.annotations.NotNull; @@ -79,7 +79,7 @@ public class PyRemoveParameterQuickFix implements LocalQuickFix { if (parameterName != null) { StreamEx - .of(PyiTypeProvider.getOverloads(function, myContext)) + .of(PyiUtil.getOverloads(function, myContext)) .map(overload -> overload.getParameterList().getParameters()) .map(parameters -> ContainerUtil.find(parameters, overloadParameter -> parameterName.equals(overloadParameter.getName()))) .nonNull() diff --git a/python/src/com/jetbrains/python/psi/impl/PyCallExpressionHelper.java b/python/src/com/jetbrains/python/psi/impl/PyCallExpressionHelper.java index b98696c86f13..645cdc5cc05b 100644 --- a/python/src/com/jetbrains/python/psi/impl/PyCallExpressionHelper.java +++ b/python/src/com/jetbrains/python/psi/impl/PyCallExpressionHelper.java @@ -32,7 +32,7 @@ import com.jetbrains.python.psi.resolve.QualifiedRatedResolveResult; import com.jetbrains.python.psi.resolve.QualifiedResolveResult; import com.jetbrains.python.psi.resolve.RatedResolveResult; import com.jetbrains.python.psi.types.*; -import com.jetbrains.python.pyi.PyiTypeProvider; +import com.jetbrains.python.pyi.PyiUtil; import com.jetbrains.python.toolbox.Maybe; import one.util.streamex.StreamEx; import org.jetbrains.annotations.NotNull; @@ -859,7 +859,7 @@ public class PyCallExpressionHelper { boolean containsImplementations = false; for (PyCallExpression.PyRatedMarkedCallee callee : callees) { - final boolean overload = PyiTypeProvider.isOverload(callee.getElement(), context); + final boolean overload = PyiUtil.isOverload(callee.getElement(), context); containsOverloads |= overload; containsImplementations |= !overload; @@ -876,7 +876,7 @@ public class PyCallExpressionHelper { return callees.stream(); } - return callees.stream().filter(callee -> PyiTypeProvider.isOverload(callee.getElement(), context)); + return callees.stream().filter(callee -> PyiUtil.isOverload(callee.getElement(), context)); } public static class ArgumentMappingResults { diff --git a/python/src/com/jetbrains/python/psi/impl/PyFileImpl.java b/python/src/com/jetbrains/python/psi/impl/PyFileImpl.java index 5d8ec19fb60b..a24d754891b9 100644 --- a/python/src/com/jetbrains/python/psi/impl/PyFileImpl.java +++ b/python/src/com/jetbrains/python/psi/impl/PyFileImpl.java @@ -54,14 +54,14 @@ import com.jetbrains.python.psi.stubs.PyFileStub; import com.jetbrains.python.psi.types.PyModuleType; import com.jetbrains.python.psi.types.PyType; import com.jetbrains.python.psi.types.TypeEvalContext; -import com.jetbrains.python.pyi.PyiTypeProvider; -import one.util.streamex.StreamEx; +import com.jetbrains.python.pyi.PyiUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import javax.swing.*; import java.io.File; import java.util.*; +import java.util.function.Function; public class PyFileImpl extends PsiFileBase implements PyFile, PyExpression { protected PyType myType; @@ -183,7 +183,10 @@ public class PyFileImpl extends PsiFileBase implements PyFile, PyExpression { } } - return containsOverloads(resultList, typeEvalContext) ? moveOverloadsBack(resultList, typeEvalContext) : resultList; + final Function mapper = RatedResolveResult::getElement; + return PyiUtil.containsOverloads(resultList, mapper, typeEvalContext) + ? PyiUtil.moveOverloadsBack(resultList, mapper, typeEvalContext) + : resultList; } synchronized (myNameDefinerNegativeCache) { @@ -195,34 +198,6 @@ public class PyFileImpl extends PsiFileBase implements PyFile, PyExpression { public long getModificationStamp() { return myModificationStamp; } - - private boolean containsOverloads(@NotNull List resolveResults, @NotNull TypeEvalContext context) { - return StreamEx - .of(resolveResults) - .map(RatedResolveResult::getElement) - .anyMatch(element -> element instanceof PyCallable && PyiTypeProvider.isOverload((PyCallable)element, context)); - } - - @NotNull - private List moveOverloadsBack(@NotNull List resolveResults, @NotNull TypeEvalContext context) { - return StreamEx - .of(resolveResults) - .sorted( - (r1, r2) -> { - final PsiElement e1 = r1.getElement(); - final PsiElement e2 = r2.getElement(); - if (e1 instanceof PyCallable && e2 instanceof PyCallable) { - final boolean firstIsOverload = PyiTypeProvider.isOverload((PyCallable)e1, context); - final boolean secondIsOverload = PyiTypeProvider.isOverload((PyCallable)e2, context); - - return Boolean.compare(firstIsOverload, secondIsOverload); - } - - return 0; - } - ) - .toList(); - } } public PyFileImpl(FileViewProvider viewProvider) { diff --git a/python/src/com/jetbrains/python/psi/impl/references/PyReferenceImpl.java b/python/src/com/jetbrains/python/psi/impl/references/PyReferenceImpl.java index 3af8266b4826..0fc8bd762625 100644 --- a/python/src/com/jetbrains/python/psi/impl/references/PyReferenceImpl.java +++ b/python/src/com/jetbrains/python/psi/impl/references/PyReferenceImpl.java @@ -45,7 +45,6 @@ import com.jetbrains.python.psi.resolve.*; import com.jetbrains.python.psi.types.PyModuleType; import com.jetbrains.python.psi.types.PyType; import com.jetbrains.python.psi.types.TypeEvalContext; -import com.jetbrains.python.pyi.PyiTypeProvider; import com.jetbrains.python.pyi.PyiUtil; import com.jetbrains.python.refactoring.PyDefUseUtil; import one.util.streamex.StreamEx; @@ -275,9 +274,9 @@ public class PyReferenceImpl implements PsiReferenceEx, PsiPolyVariantReference if (ContainerUtil.exists(latestDefs, result -> result.getElement() instanceof PyCallable)) { return StreamEx .of(processor.getResults().keySet()) - .select(PyCallable.class) - .filter(callable -> PyiTypeProvider.isOverload(callable, typeEvalContext)) - .map(callable -> new RatedResolveResult(getRate(callable, typeEvalContext), callable)) + .nonNull() + .filter(element -> PyiUtil.isOverload(element, typeEvalContext)) + .map(element -> new RatedResolveResult(getRate(element, typeEvalContext), element)) .prepend(latestDefs) .toList(); } diff --git a/python/src/com/jetbrains/python/psi/types/PyClassTypeImpl.java b/python/src/com/jetbrains/python/psi/types/PyClassTypeImpl.java index 3eb2bb07cf38..e551668a3e7f 100644 --- a/python/src/com/jetbrains/python/psi/types/PyClassTypeImpl.java +++ b/python/src/com/jetbrains/python/psi/types/PyClassTypeImpl.java @@ -44,15 +44,14 @@ import com.jetbrains.python.psi.resolve.CompletionVariantsProcessor; import com.jetbrains.python.psi.resolve.PyResolveContext; import com.jetbrains.python.psi.resolve.PyResolveProcessor; import com.jetbrains.python.psi.resolve.RatedResolveResult; -import com.jetbrains.python.pyi.PyiTypeProvider; +import com.jetbrains.python.pyi.PyiUtil; import com.jetbrains.python.toolbox.Maybe; -import one.util.streamex.StreamEx; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.*; +import java.util.function.Function; import java.util.stream.Collectors; -import java.util.stream.Stream; import static com.jetbrains.python.psi.PyUtil.as; import static com.jetbrains.python.psi.resolve.PyResolveImportUtil.fromFoothold; @@ -555,44 +554,20 @@ public class PyClassTypeImpl extends UserDataHolderBase implements PyClassType { @Nullable PyExpression location, @NotNull TypeEvalContext context) { final PyResolveProcessor processor = new PyResolveProcessor(name); - final Stream result; + final Collection result; if (!isDefinition && !cls.processInstanceLevelDeclarations(processor, location)) { - result = processor.getElements().stream(); + result = processor.getElements(); } else { cls.processClassLevelDeclarations(processor); final Collection elements = processor.getElements(); - result = containsOverloads(elements, context) ? moveOverloadsBack(elements, context) : elements.stream(); + result = PyiUtil.containsOverloads(elements, Function.identity(), context) + ? PyiUtil.moveOverloadsBack(elements, Function.identity(), context) + : elements; } - return StreamEx - .of(result) - .map(element -> new RatedResolveResult(RatedResolveResult.RATE_NORMAL, element)) - .toList(); - } - - private static boolean containsOverloads(@NotNull Collection elements, @NotNull TypeEvalContext context) { - return ContainerUtil.exists(elements, - element -> element instanceof PyCallable && PyiTypeProvider.isOverload((PyCallable)element, context)); - } - - @NotNull - private static Stream moveOverloadsBack(@NotNull Collection elements, @NotNull TypeEvalContext context) { - return elements - .stream() - .sorted( - (e1, e2) -> { - if (e1 instanceof PyCallable && e2 instanceof PyCallable) { - final boolean firstIsOverload = PyiTypeProvider.isOverload((PyCallable)e1, context); - final boolean secondIsOverload = PyiTypeProvider.isOverload((PyCallable)e2, context); - - return Boolean.compare(firstIsOverload, secondIsOverload); - } - - return 0; - } - ); + return ContainerUtil.map(result, element -> new RatedResolveResult(RatedResolveResult.RATE_NORMAL, element)); } private static Key> CTX_VISITED = Key.create("PyClassType.Visited"); diff --git a/python/src/com/jetbrains/python/pyi/PyiTypeProvider.java b/python/src/com/jetbrains/python/pyi/PyiTypeProvider.java index 211cbe2250ae..ddde12e6cb3c 100644 --- a/python/src/com/jetbrains/python/pyi/PyiTypeProvider.java +++ b/python/src/com/jetbrains/python/pyi/PyiTypeProvider.java @@ -15,12 +15,8 @@ */ package com.jetbrains.python.pyi; -import com.google.common.collect.ImmutableSet; import com.intellij.openapi.util.Ref; import com.intellij.psi.PsiElement; -import com.intellij.util.Processor; -import com.jetbrains.python.codeInsight.controlflow.ScopeOwner; -import com.jetbrains.python.codeInsight.dataflow.scope.ScopeUtil; import com.jetbrains.python.psi.*; import com.jetbrains.python.psi.impl.PyCallExpressionHelper; import com.jetbrains.python.psi.types.*; @@ -72,14 +68,14 @@ public class PyiTypeProvider extends PyTypeProviderBase { final PsiElement pythonStub = PyiUtil.getPythonStub(callable); if (pythonStub instanceof PyFunction) { final PyFunction functionStub = (PyFunction)pythonStub; - if (isOverload(functionStub, context)) { + if (PyiUtil.isOverload(functionStub, context)) { return getOverloadType(functionStub, context); } return new PyFunctionTypeImpl(functionStub); } else if (callable.getContainingFile() instanceof PyiFile && callable instanceof PyFunction) { final PyFunction functionStub = (PyFunction)callable; - if (isOverload(functionStub, context)) { + if (PyiUtil.isOverload(functionStub, context)) { return getOverloadType(functionStub, context); } } @@ -107,8 +103,8 @@ public class PyiTypeProvider extends PyTypeProviderBase { private static Ref getOverloadedCallType(@NotNull PyFunction function, @NotNull PyCallSiteExpression callSite, @NotNull TypeEvalContext context) { - if (isOverload(function, context)) { - final List overloads = getOverloads(function, context); + if (PyiUtil.isOverload(function, context)) { + final List overloads = PyiUtil.getOverloads(function, context); final List allReturnTypes = new ArrayList<>(); final List matchedReturnTypes = new ArrayList<>(); @@ -151,7 +147,7 @@ public class PyiTypeProvider extends PyTypeProviderBase { @Nullable private static PyType getOverloadType(@NotNull PyFunction function, @NotNull final TypeEvalContext context) { - final List overloads = getOverloads(function, context); + final List overloads = PyiUtil.getOverloads(function, context); if (!overloads.isEmpty()) { final List overloadTypes = new ArrayList<>(); for (PyFunction overload : overloads) { @@ -162,46 +158,6 @@ public class PyiTypeProvider extends PyTypeProviderBase { return null; } - @NotNull - public static List getOverloads(@NotNull PyFunction function, @NotNull TypeEvalContext context) { - final ScopeOwner owner = ScopeUtil.getScopeOwner(function); - final String name = function.getName(); - final List overloads = new ArrayList<>(); - final Processor overloadsProcessor = f -> { - if (name != null && name.equals(f.getName()) && isOverload(f, context)) { - overloads.add(f); - } - return true; - }; - if (owner instanceof PyClass) { - final PyClass cls = (PyClass)owner; - if (name != null) { - cls.visitMethods(overloadsProcessor, false, context); - } - } - else if (owner instanceof PyFile) { - final PyFile file = (PyFile)owner; - for (PyFunction f : file.getTopLevelFunctions()) { - if (!overloadsProcessor.process(f)) { - break; - } - } - } - return overloads; - } - - public static boolean isOverload(@NotNull PyCallable callable, @NotNull TypeEvalContext context) { - if (callable instanceof PyDecoratable) { - final PyDecoratable decorated = (PyDecoratable)callable; - final ImmutableSet decorators = - ImmutableSet.copyOf(PyKnownDecoratorUtil.getKnownDecorators(decorated, context)); - if (decorators.contains(PyKnownDecoratorUtil.KnownDecorator.TYPING_OVERLOAD)) { - return true; - } - } - return false; - } - @Nullable private static PyCallExpressionHelper.ArgumentMappingResults mapArguments(@NotNull PyCallSiteExpression callSite, @NotNull PyFunction function, diff --git a/python/src/com/jetbrains/python/pyi/PyiUtil.java b/python/src/com/jetbrains/python/pyi/PyiUtil.java index 069346279cbe..ab1136524cac 100644 --- a/python/src/com/jetbrains/python/pyi/PyiUtil.java +++ b/python/src/com/jetbrains/python/pyi/PyiUtil.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2015 JetBrains s.r.o. + * Copyright 2000-2017 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. @@ -19,6 +19,8 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.QualifiedName; +import com.intellij.util.Processor; +import com.intellij.util.containers.ContainerUtil; import com.jetbrains.python.codeInsight.controlflow.ScopeOwner; import com.jetbrains.python.codeInsight.dataflow.scope.ScopeUtil; import com.jetbrains.python.psi.*; @@ -26,10 +28,14 @@ import com.jetbrains.python.psi.resolve.*; import com.jetbrains.python.psi.types.PyClassLikeType; import com.jetbrains.python.psi.types.PyType; import com.jetbrains.python.psi.types.TypeEvalContext; +import one.util.streamex.StreamEx; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.ArrayList; +import java.util.Collection; import java.util.List; +import java.util.function.Function; /** * @author vlan @@ -69,6 +75,57 @@ public class PyiUtil { return null; } + @NotNull + public static List getOverloads(@NotNull PyFunction function, @NotNull TypeEvalContext context) { + final ScopeOwner owner = ScopeUtil.getScopeOwner(function); + final String name = function.getName(); + final List overloads = new ArrayList<>(); + final Processor overloadsProcessor = f -> { + if (name != null && name.equals(f.getName()) && isOverload(f, context)) { + overloads.add(f); + } + return true; + }; + if (owner instanceof PyClass) { + final PyClass cls = (PyClass)owner; + if (name != null) { + cls.visitMethods(overloadsProcessor, false, context); + } + } + else if (owner instanceof PyFile) { + final PyFile file = (PyFile)owner; + for (PyFunction f : file.getTopLevelFunctions()) { + if (!overloadsProcessor.process(f)) { + break; + } + } + } + return overloads; + } + + public static boolean isOverload(@NotNull PsiElement element, @NotNull TypeEvalContext context) { + final PyKnownDecoratorUtil.KnownDecorator overload = PyKnownDecoratorUtil.KnownDecorator.TYPING_OVERLOAD; + + return element instanceof PyFunction && + PyKnownDecoratorUtil.getKnownDecorators((PyFunction)element, context).contains(overload); + } + + public static boolean containsOverloads(@NotNull Collection elements, + @NotNull Function mapper, + @NotNull TypeEvalContext context) { + return ContainerUtil.exists(elements, element -> isOverload(mapper.apply(element), context)); + } + + @NotNull + public static List moveOverloadsBack(@NotNull Collection elements, + @NotNull Function mapper, + @NotNull TypeEvalContext context) { + return StreamEx + .of(elements) + .sorted((e1, e2) -> Boolean.compare(isOverload(mapper.apply(e1), context), isOverload(mapper.apply(e2), context))) + .toList(); + } + @Nullable private static PyiFile getPythonStubFile(@NotNull PyFile file) { final QualifiedName name = QualifiedNameFinder.findCanonicalImportPath(file, file); diff --git a/python/testSrc/com/jetbrains/python/Py3ResolveTest.java b/python/testSrc/com/jetbrains/python/Py3ResolveTest.java index 2fe792b7157a..aadf25fc30e0 100644 --- a/python/testSrc/com/jetbrains/python/Py3ResolveTest.java +++ b/python/testSrc/com/jetbrains/python/Py3ResolveTest.java @@ -25,7 +25,7 @@ import com.jetbrains.python.psi.*; import com.jetbrains.python.psi.impl.PyPsiUtils; import com.jetbrains.python.psi.impl.PythonLanguageLevelPusher; import com.jetbrains.python.psi.types.TypeEvalContext; -import com.jetbrains.python.pyi.PyiTypeProvider; +import com.jetbrains.python.pyi.PyiUtil; /** * @author yole @@ -377,7 +377,7 @@ public class Py3ResolveTest extends PyResolveTestCase { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - PyiTypeProvider + PyiUtil .getOverloads(foo, context) .forEach( overload -> { @@ -396,7 +396,7 @@ public class Py3ResolveTest extends PyResolveTestCase { () -> { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - assertFalse(PyiTypeProvider.isOverload(foo, context)); + assertFalse(PyiUtil.isOverload(foo, context)); } ); } @@ -409,14 +409,14 @@ public class Py3ResolveTest extends PyResolveTestCase { () -> { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - assertFalse(PyiTypeProvider.isOverload(foo, context)); + assertFalse(PyiUtil.isOverload(foo, context)); final PyClass pyClass = foo.getContainingClass(); assertNotNull(pyClass); pyClass.visitMethods( function -> { - assertTrue(PyiTypeProvider.isOverload(function, context) || function == foo || PyPsiUtils.isBefore(foo, function)); + assertTrue(PyiUtil.isOverload(function, context) || function == foo || PyPsiUtils.isBefore(foo, function)); return true; }, false, @@ -435,7 +435,7 @@ public class Py3ResolveTest extends PyResolveTestCase { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - PyiTypeProvider + PyiUtil .getOverloads(foo, context) .forEach( overload -> { @@ -454,7 +454,7 @@ public class Py3ResolveTest extends PyResolveTestCase { () -> { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - assertFalse(PyiTypeProvider.isOverload(foo, context)); + assertFalse(PyiUtil.isOverload(foo, context)); } ); } @@ -467,7 +467,7 @@ public class Py3ResolveTest extends PyResolveTestCase { () -> { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - assertTrue(PyiTypeProvider.isOverload(foo, context)); + assertTrue(PyiUtil.isOverload(foo, context)); ((PyFile)foo.getContainingFile()) .getTopLevelFunctions() @@ -488,7 +488,7 @@ public class Py3ResolveTest extends PyResolveTestCase { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - PyiTypeProvider + PyiUtil .getOverloads(foo, context) .forEach( overload -> { @@ -508,7 +508,7 @@ public class Py3ResolveTest extends PyResolveTestCase { () -> { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - assertFalse(PyiTypeProvider.isOverload(foo, context)); + assertFalse(PyiUtil.isOverload(foo, context)); } ); } @@ -522,14 +522,14 @@ public class Py3ResolveTest extends PyResolveTestCase { () -> { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - assertFalse(PyiTypeProvider.isOverload(foo, context)); + assertFalse(PyiUtil.isOverload(foo, context)); final PyClass pyClass = foo.getContainingClass(); assertNotNull(pyClass); pyClass.visitMethods( function -> { - assertTrue(PyiTypeProvider.isOverload(function, context) || function == foo || PyPsiUtils.isBefore(foo, function)); + assertTrue(PyiUtil.isOverload(function, context) || function == foo || PyPsiUtils.isBefore(foo, function)); return true; }, false, @@ -549,7 +549,7 @@ public class Py3ResolveTest extends PyResolveTestCase { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - PyiTypeProvider + PyiUtil .getOverloads(foo, context) .forEach( overload -> { @@ -569,7 +569,7 @@ public class Py3ResolveTest extends PyResolveTestCase { () -> { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - assertFalse(PyiTypeProvider.isOverload(foo, context)); + assertFalse(PyiUtil.isOverload(foo, context)); } ); } @@ -583,12 +583,12 @@ public class Py3ResolveTest extends PyResolveTestCase { () -> { final PyFunction foo = assertResolvesTo(PyFunction.class, "foo"); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()); - assertFalse(PyiTypeProvider.isOverload(foo, context)); + assertFalse(PyiUtil.isOverload(foo, context)); ((PyFile)foo.getContainingFile()) .getTopLevelFunctions() .forEach( - function -> assertTrue(PyiTypeProvider.isOverload(function, context) || function == foo || PyPsiUtils.isBefore(function, foo)) + function -> assertTrue(PyiUtil.isOverload(function, context) || function == foo || PyPsiUtils.isBefore(function, foo)) ); } );