mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-27 10:03:11 +07:00
Changed PyClass.iterateAncestorClasses() to getAncestorClasses()
This commit is contained in:
@@ -110,7 +110,8 @@ public interface PyClass extends PsiNameIdentifierOwner, PyStatement, NameDefine
|
||||
*/
|
||||
boolean isNewStyleClass();
|
||||
|
||||
Iterable<PyClass> iterateAncestorClasses();
|
||||
@NotNull
|
||||
List<PyClass> getAncestorClasses();
|
||||
|
||||
/**
|
||||
* Get a list of all ancestor types.
|
||||
|
||||
@@ -70,7 +70,7 @@ public class PyGotoSuperHandler implements CodeInsightActionHandler {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
final List<PyTargetExpression> result = new ArrayList<PyTargetExpression>();
|
||||
for (PyClass aClass: pyClass.iterateAncestorClasses()) {
|
||||
for (PyClass aClass: pyClass.getAncestorClasses()) {
|
||||
final PyTargetExpression superAttr = aClass.findClassAttribute(name, false);
|
||||
if (superAttr != null) {
|
||||
result.add(superAttr);
|
||||
@@ -85,7 +85,7 @@ public class PyGotoSuperHandler implements CodeInsightActionHandler {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
final List<PyFunction> result = new ArrayList<PyFunction>();
|
||||
for (PyClass aClass: pyClass.iterateAncestorClasses()) {
|
||||
for (PyClass aClass: pyClass.getAncestorClasses()) {
|
||||
final PyFunction byName = aClass.findMethodByName(name, false);
|
||||
if (byName != null) {
|
||||
result.add(byName);
|
||||
|
||||
@@ -108,7 +108,7 @@ public class PyLineMarkerProvider implements LineMarkerProvider, PyLineSeparator
|
||||
List<PsiElement> result = new ArrayList<PsiElement>();
|
||||
PyClass containingClass = PsiTreeUtil.getParentOfType(elt, PyClass.class);
|
||||
if (containingClass != null && elt instanceof PyTargetExpression) {
|
||||
for (PyClass ancestor : containingClass.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : containingClass.getAncestorClasses()) {
|
||||
final PyTargetExpression attribute = ancestor.findClassAttribute(((PyTargetExpression)elt).getReferencedName(), false);
|
||||
if (attribute != null) {
|
||||
result.add(attribute);
|
||||
@@ -185,7 +185,7 @@ public class PyLineMarkerProvider implements LineMarkerProvider, PyLineSeparator
|
||||
}
|
||||
PyClass containingClass = PsiTreeUtil.getParentOfType(element, PyClass.class);
|
||||
if (containingClass == null) return null;
|
||||
for (PyClass ancestor : containingClass.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : containingClass.getAncestorClasses()) {
|
||||
final PyTargetExpression ancestorAttr = ancestor.findClassAttribute(name, false);
|
||||
if (ancestorAttr != null) {
|
||||
return new LineMarkerInfo<PsiElement>(element, element.getTextRange().getStartOffset(),
|
||||
|
||||
+1
-1
@@ -45,7 +45,7 @@ public class PySuperClassAttributesCompletionContributor extends CompletionContr
|
||||
for (PyTargetExpression expr : cls.getClassAttributes()) {
|
||||
seenNames.add(expr.getName());
|
||||
}
|
||||
for (PyClass ancestor : cls.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : cls.getAncestorClasses()) {
|
||||
for (PyTargetExpression expr : ancestor.getClassAttributes()) {
|
||||
if (!seenNames.contains(expr.getName())) {
|
||||
seenNames.add(expr.getName());
|
||||
|
||||
+1
-1
@@ -47,7 +47,7 @@ public class PySuperMethodCompletionContributor extends CompletionContributor {
|
||||
}
|
||||
LanguageLevel languageLevel = LanguageLevel.forElement(parameters.getOriginalFile());
|
||||
seenNames.addAll(PyNames.getBuiltinMethods(languageLevel).keySet());
|
||||
for (PyClass ancestor : containingClass.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : containingClass.getAncestorClasses()) {
|
||||
for (PyFunction superMethod : ancestor.getMethods()) {
|
||||
if (!seenNames.contains(superMethod.getName())) {
|
||||
String text = superMethod.getName() + superMethod.getParameterList().getText();
|
||||
|
||||
@@ -239,7 +239,7 @@ public class PyOverrideImplementUtil {
|
||||
@NotNull
|
||||
private static Collection<PyFunction> getAllSuperFunctions(@NotNull final PyClass pyClass) {
|
||||
final Map<String, PyFunction> superFunctions = new HashMap<String, PyFunction>();
|
||||
for (PyClass aClass : pyClass.iterateAncestorClasses()) {
|
||||
for (PyClass aClass : pyClass.getAncestorClasses()) {
|
||||
for (PyFunction function : aClass.getMethods()) {
|
||||
if (!superFunctions.containsKey(function.getName())) {
|
||||
superFunctions.put(function.getName(), function);
|
||||
|
||||
@@ -286,7 +286,7 @@ class PyDocumentationBuilder {
|
||||
if (cls != null && meth_name != null) {
|
||||
final boolean is_constructor = PyNames.INIT.equals(meth_name);
|
||||
// look for inherited and its doc
|
||||
Iterable<PyClass> classes = cls.iterateAncestorClasses();
|
||||
Iterable<PyClass> classes = cls.getAncestorClasses();
|
||||
if (is_constructor) {
|
||||
// look at our own class again and maybe inherit class's doc
|
||||
classes = new ChainIterable<PyClass>(cls).add(classes);
|
||||
|
||||
@@ -313,7 +313,7 @@ public class PythonDocumentationProvider extends AbstractDocumentationProvider i
|
||||
PyClass cls = inferContainingClassOf(context);
|
||||
if (cls != null) {
|
||||
String desired_name = link.substring(LINK_TYPE_PARENT.length());
|
||||
for (PyClass parent : cls.iterateAncestorClasses()) {
|
||||
for (PyClass parent : cls.getAncestorClasses()) {
|
||||
final String parent_name = parent.getName();
|
||||
if (parent_name != null && parent_name.equals(desired_name)) return parent;
|
||||
}
|
||||
|
||||
@@ -65,7 +65,7 @@ public class PyAttributeOutsideInitInspection extends PyInspection {
|
||||
collectAttributesFromSuper(attributesInInit, initMethod);
|
||||
}
|
||||
else {
|
||||
for (PyClass superClass : containingClass.iterateAncestorClasses()) {
|
||||
for (PyClass superClass : containingClass.getAncestorClasses()) {
|
||||
final PyFunction superInit = superClass.findMethodByName(PyNames.INIT, false);
|
||||
if (superInit != null)
|
||||
PyClassImpl.collectInstanceAttributes(superInit, attributesInInit);
|
||||
|
||||
@@ -44,7 +44,7 @@ public class PyClassHasNoInitInspection extends PyInspection {
|
||||
registerProblem(node.getNameIdentifier(), PyBundle.message("INSP.class.has.no.init"),
|
||||
new AddMethodQuickFix("__init__", new PyClassTypeImpl(node, false), false));
|
||||
}
|
||||
for (PyClass ancestor : node.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : node.getAncestorClasses()) {
|
||||
final PyFunction ancestorInit = ancestor.findInitOrNew(false);
|
||||
if (ancestorInit == null) {
|
||||
registerProblem(node.getNameIdentifier(), PyBundle.message("INSP.parent.$0.has.no.init", ancestor.getName()),
|
||||
|
||||
@@ -62,7 +62,7 @@ public class PyMissingConstructorInspection extends PyInspection {
|
||||
}
|
||||
|
||||
private static boolean superHasConstructor(@NotNull PyClass cls) {
|
||||
for (PyClass c : cls.iterateAncestorClasses()) {
|
||||
for (PyClass c : cls.getAncestorClasses()) {
|
||||
final String name = c.getName();
|
||||
final String className = cls.getName();
|
||||
if (!OBJECT.equals(name) && !FAKE_OLD_BASE.equals(name) && className != null &&
|
||||
@@ -77,7 +77,7 @@ public class PyMissingConstructorInspection extends PyInspection {
|
||||
if (PyBroadExceptionInspection.equalsException(cls, context)) {
|
||||
return true;
|
||||
}
|
||||
for (PyClass baseClass : cls.iterateAncestorClasses()) {
|
||||
for (PyClass baseClass : cls.getAncestorClasses()) {
|
||||
if (PyBroadExceptionInspection.equalsException(baseClass, context)) {
|
||||
return true;
|
||||
}
|
||||
@@ -127,7 +127,7 @@ public class PyMissingConstructorInspection extends PyInspection {
|
||||
if (firstArg.equals(cl.getName()) || firstArg.equals(CANONICAL_SELF+"."+ CLASS) ||
|
||||
(qualifiedName != null && qualifiedName.endsWith(firstArg)))
|
||||
return true;
|
||||
for (PyClass s : cl.iterateAncestorClasses()) {
|
||||
for (PyClass s : cl.getAncestorClasses()) {
|
||||
if (firstArg.equals(s.getName()))
|
||||
return true;
|
||||
}
|
||||
@@ -159,7 +159,7 @@ public class PyMissingConstructorInspection extends PyInspection {
|
||||
if (ref != null)
|
||||
callingClass = ref.resolve();
|
||||
}
|
||||
for (PyClass s : cl.iterateAncestorClasses()) {
|
||||
for (PyClass s : cl.getAncestorClasses()) {
|
||||
if (s.equals(callingClass)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -134,7 +134,7 @@ public class PyUnresolvedReferencesInspection extends PyInspection {
|
||||
final List<String> slots = pyClass.getSlots();
|
||||
final String attrName = node.getReferencedName();
|
||||
if (slots != null && !slots.contains(attrName) && !slots.contains(PyNames.DICT)) {
|
||||
for (PyClass ancestor : pyClass.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : pyClass.getAncestorClasses()) {
|
||||
if (ancestor == null) {
|
||||
return;
|
||||
}
|
||||
@@ -672,7 +672,7 @@ public class PyUnresolvedReferencesInspection extends PyInspection {
|
||||
if (isDecoratedAsDynamic(cls, false)) {
|
||||
return true;
|
||||
}
|
||||
for (PyClass base : cls.iterateAncestorClasses()) {
|
||||
for (PyClass base : cls.getAncestorClasses()) {
|
||||
if (base != null && isDecoratedAsDynamic(base, false)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -105,7 +105,7 @@ public class AddFieldQuickFix implements LocalQuickFix {
|
||||
return appendToMethod(init, callback);
|
||||
}
|
||||
else { // no init! boldly copy ancestor's.
|
||||
for (PyClass ancestor : cls.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : cls.getAncestorClasses()) {
|
||||
init = ancestor.findMethodByName(PyNames.INIT, false);
|
||||
if (init != null) break;
|
||||
}
|
||||
|
||||
@@ -375,7 +375,7 @@ public class PyUtil {
|
||||
@NotNull
|
||||
public static List<PyClass> getAllSuperClasses(@NotNull PyClass pyClass) {
|
||||
List<PyClass> superClasses = new ArrayList<PyClass>();
|
||||
for (PyClass ancestor : pyClass.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : pyClass.getAncestorClasses()) {
|
||||
if (!PyNames.FAKE_OLD_BASE.equals(ancestor.getName())) {
|
||||
superClasses.add(ancestor);
|
||||
}
|
||||
@@ -1018,7 +1018,7 @@ public class PyUtil {
|
||||
PyFunction.Modifier modifier = node.getModifier();
|
||||
boolean isMetaclassMethod = false;
|
||||
PyClass type_cls = PyBuiltinCache.getInstance(node).getClass("type");
|
||||
for (PyClass ancestor_cls : cls.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor_cls : cls.getAncestorClasses()) {
|
||||
if (ancestor_cls == type_cls) {
|
||||
isMetaclassMethod = true;
|
||||
break;
|
||||
@@ -1050,7 +1050,7 @@ public class PyUtil {
|
||||
if (firstArg.equals(klass.getName()) || firstArg.equals(PyNames.CANONICAL_SELF + "." + PyNames.CLASS)) {
|
||||
return true;
|
||||
}
|
||||
for (PyClass s : klass.iterateAncestorClasses()) {
|
||||
for (PyClass s : klass.getAncestorClasses()) {
|
||||
if (firstArg.equals(s.getName())) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -505,7 +505,7 @@ public class PyCallExpressionHelper {
|
||||
return getSuperClassUnionType(firstClass);
|
||||
}
|
||||
if (secondClass.isSubclass(firstClass)) {
|
||||
final Iterator<PyClass> iterator = firstClass.iterateAncestorClasses().iterator();
|
||||
final Iterator<PyClass> iterator = firstClass.getAncestorClasses().iterator();
|
||||
if (iterator.hasNext()) {
|
||||
return new PyClassTypeImpl(iterator.next(), false); // super(Foo, self) has type of Foo, modulo __get__()
|
||||
}
|
||||
|
||||
@@ -174,8 +174,9 @@ public class PyClassImpl extends PyPresentableElementImpl<PyClassStub> implement
|
||||
return expression;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Iterable<PyClass> iterateAncestorClasses() {
|
||||
public List<PyClass> getAncestorClasses() {
|
||||
final List<PyClass> results = new ArrayList<PyClass>();
|
||||
for (PyClassLikeType type : getAncestorTypes(TypeEvalContext.fastStubOnly(null))) {
|
||||
if (type instanceof PyClassType) {
|
||||
@@ -189,7 +190,7 @@ public class PyClassImpl extends PyPresentableElementImpl<PyClassStub> implement
|
||||
if (this == parent) {
|
||||
return true;
|
||||
}
|
||||
for (PyClass superclass : iterateAncestorClasses()) {
|
||||
for (PyClass superclass : getAncestorClasses()) {
|
||||
if (parent == superclass) return true;
|
||||
}
|
||||
return false;
|
||||
@@ -243,7 +244,7 @@ public class PyClassImpl extends PyPresentableElementImpl<PyClassStub> implement
|
||||
if (slots != null) {
|
||||
return slots;
|
||||
}
|
||||
for (PyClass cls : iterateAncestorClasses()) {
|
||||
for (PyClass cls : getAncestorClasses()) {
|
||||
slots = ((PyClassImpl)cls).getOwnSlots();
|
||||
if (slots != null) {
|
||||
return slots;
|
||||
@@ -549,7 +550,7 @@ public class PyClassImpl extends PyPresentableElementImpl<PyClassStub> implement
|
||||
if (findMethodByName(name, false) != null || findClassAttribute(name, false) != null) {
|
||||
return null;
|
||||
}
|
||||
for (PyClass aClass : iterateAncestorClasses()) {
|
||||
for (PyClass aClass : getAncestorClasses()) {
|
||||
final Property ancestorProperty = ((PyClassImpl)aClass).findLocalProperty(name);
|
||||
if (ancestorProperty != null) {
|
||||
return ancestorProperty;
|
||||
@@ -621,7 +622,7 @@ public class PyClassImpl extends PyPresentableElementImpl<PyClassStub> implement
|
||||
if (name != null && (findMethodByName(name, false) != null || findClassAttribute(name, false) != null)) {
|
||||
return null;
|
||||
}
|
||||
for (PyClass cls : iterateAncestorClasses()) {
|
||||
for (PyClass cls : getAncestorClasses()) {
|
||||
final Property property = ((PyClassImpl)cls).processPropertiesInClass(name, filter, useAdvancedSyntax);
|
||||
if (property != null) {
|
||||
return property;
|
||||
@@ -713,7 +714,7 @@ public class PyClassImpl extends PyPresentableElementImpl<PyClassStub> implement
|
||||
PyFunction[] methods = getMethods();
|
||||
if (!ContainerUtil.process(methods, processor)) return false;
|
||||
if (inherited) {
|
||||
for (PyClass ancestor : iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : getAncestorClasses()) {
|
||||
if (skipClassObj && PyNames.FAKE_OLD_BASE.equals(ancestor.getName())) {
|
||||
continue;
|
||||
}
|
||||
@@ -729,7 +730,7 @@ public class PyClassImpl extends PyPresentableElementImpl<PyClassStub> implement
|
||||
PyClass[] nestedClasses = getNestedClasses();
|
||||
if (!ContainerUtil.process(nestedClasses, processor)) return false;
|
||||
if (inherited) {
|
||||
for (PyClass ancestor : iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : getAncestorClasses()) {
|
||||
if (!((PyClassImpl)ancestor).visitNestedClasses(processor, false)) {
|
||||
return false;
|
||||
}
|
||||
@@ -742,7 +743,7 @@ public class PyClassImpl extends PyPresentableElementImpl<PyClassStub> implement
|
||||
List<PyTargetExpression> methods = getClassAttributes();
|
||||
if (!ContainerUtil.process(methods, processor)) return false;
|
||||
if (inherited) {
|
||||
for (PyClass ancestor : iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : getAncestorClasses()) {
|
||||
if (!ancestor.visitClassAttributes(processor, false)) {
|
||||
return false;
|
||||
}
|
||||
@@ -797,7 +798,7 @@ public class PyClassImpl extends PyPresentableElementImpl<PyClassStub> implement
|
||||
}
|
||||
}
|
||||
if (inherited) {
|
||||
for (PyClass ancestor : iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : getAncestorClasses()) {
|
||||
final PyTargetExpression attribute = ancestor.findInstanceAttribute(name, false);
|
||||
if (attribute != null) {
|
||||
return attribute;
|
||||
|
||||
@@ -125,7 +125,7 @@ public class PyReferenceImpl implements PsiReferenceEx, PsiPolyVariantReference
|
||||
it.set(rrr.replace(init));
|
||||
}
|
||||
else { // init not found; maybe it's ancestor's
|
||||
for (PyClass ancestor : cls.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : cls.getAncestorClasses()) {
|
||||
init = ancestor.findMethodByName(PyNames.INIT, false);
|
||||
if (init != null) {
|
||||
// add to results as low priority
|
||||
|
||||
@@ -18,7 +18,7 @@ public class PySuperMethodsSearch extends ExtensibleQueryFactory<PsiElement, PyS
|
||||
private static PyFunction getBaseMethod(List<PsiElement> superMethods,
|
||||
PyClass containingClass) {
|
||||
|
||||
for (PyClass ancestor : containingClass.iterateAncestorClasses()) {
|
||||
for (PyClass ancestor : containingClass.getAncestorClasses()) {
|
||||
for (PsiElement method : superMethods) {
|
||||
if (ancestor.equals(((PyFunction)method).getContainingClass()))
|
||||
return (PyFunction)method;
|
||||
|
||||
@@ -19,7 +19,7 @@ public class PySuperMethodsSearchExecutor implements QueryExecutor<PsiElement, P
|
||||
PyClass containingClass = func.getContainingClass();
|
||||
Set<PyClass> foundMethodContainingClasses = new HashSet<PyClass>();
|
||||
if (name != null && containingClass != null) {
|
||||
for (PyClass superClass : containingClass.iterateAncestorClasses()) {
|
||||
for (PyClass superClass : containingClass.getAncestorClasses()) {
|
||||
if (!queryParameters.isDeepSearch()) {
|
||||
boolean isAlreadyFound = false;
|
||||
for (PyClass alreadyFound : foundMethodContainingClasses) {
|
||||
|
||||
@@ -155,7 +155,7 @@ public class PyClassTypeImpl extends UserDataHolderBase implements PyClassType {
|
||||
PyType first_arg_type = context.getType(first_arg);
|
||||
if (first_arg_type instanceof PyClassType) {
|
||||
PyClass derived_class = ((PyClassType)first_arg_type).getPyClass();
|
||||
final Iterator<PyClass> base_it = derived_class.iterateAncestorClasses().iterator();
|
||||
final Iterator<PyClass> base_it = derived_class.getAncestorClasses().iterator();
|
||||
if (base_it.hasNext()) {
|
||||
return new PyClassTypeImpl(base_it.next(), true).resolveMember(name, location, direction, resolveContext);
|
||||
}
|
||||
|
||||
@@ -111,7 +111,7 @@ public class PyStructureViewElement implements StructureViewTreeElement {
|
||||
children.add(createChild(e, getElementVisibility(e), false, elementIsField(e)));
|
||||
}
|
||||
if (myElement instanceof PyClass && myElement.isValid()) {
|
||||
for (PyClass c : ((PyClass)myElement).iterateAncestorClasses()) {
|
||||
for (PyClass c : ((PyClass)myElement).getAncestorClasses()) {
|
||||
for (PyElement e: getElementChildren(c)) {
|
||||
final StructureViewTreeElement inherited = createChild(e, getElementVisibility(e), true, elementIsField(e));
|
||||
if (!children.contains(inherited)) {
|
||||
|
||||
@@ -347,7 +347,7 @@ public class PyStubsTest extends PyTestCase {
|
||||
public void testBuiltinAncestor() {
|
||||
final PyFileImpl file = (PyFileImpl) getTestFile();
|
||||
final PyClass pyClass = file.getTopLevelClasses().get(0);
|
||||
final PyClass cls = pyClass.iterateAncestorClasses().iterator().next();
|
||||
final PyClass cls = pyClass.getAncestorClasses().iterator().next();
|
||||
assertNotNull(cls);
|
||||
assertNotParsed(file);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user