@Override
public void visitPyAssignmentStatement(PyAssignmentStatement node) {
final PyExpression value = node.getAssignedValue();
if (value instanceof PyCallExpression) {
final PyType type = myTypeEvalContext.getType(value);
final PyExpression callee = ((PyCallExpression) value).getCallee();
if (type instanceof PyNoneType && callee != null) {
final PyTypeChecker.AnalyzeCallResults analyzeCallResults =
PyTypeChecker.analyzeCall(((PyCallExpression) value), myTypeEvalContext);
if (analyzeCallResults != null) {
final PyCallable callable = analyzeCallResults.getCallable();
if (PySdkUtil.isElementInSkeletons(callable)) {
return;
}
if (callable instanceof PyFunction) {
final PyFunction function = (PyFunction) callable;
// Currently we don't infer types returned by decorators
if (hasInheritors(function) || PyUtil.hasCustomDecorators(function)) {
return;
}
}
registerProblem(
node,
PyBundle.message("INSP.none.function.assignment", callee.getName()),
new PyRemoveAssignmentQuickFix());
}
}
}
}
/**
* Looks for two standard decorators to a function, or a wrapping assignment that closely follows
* it.
*
* @return a flag describing what was detected.
*/
@Nullable
public Modifier getModifier() {
String deconame = getClassOrStaticMethodDecorator();
if (PyNames.CLASSMETHOD.equals(deconame)) {
return CLASSMETHOD;
} else if (PyNames.STATICMETHOD.equals(deconame)) {
return STATICMETHOD;
}
// implicit staticmethod __new__
PyClass cls = getContainingClass();
if (cls != null && PyNames.NEW.equals(getName()) && cls.isNewStyleClass()) {
return STATICMETHOD;
}
//
if (getStub() != null) {
return getWrappersFromStub();
}
String func_name = getName();
if (func_name != null) {
PyAssignmentStatement assignment =
PsiTreeUtil.getNextSiblingOfType(this, PyAssignmentStatement.class);
if (assignment != null) {
for (Pair<PyExpression, PyExpression> pair : assignment.getTargetsToValuesMapping()) {
PyExpression value = pair.getSecond();
if (value instanceof PyCallExpression) {
PyExpression target = pair.getFirst();
if (target instanceof PyTargetExpression && func_name.equals(target.getName())) {
Pair<String, PyFunction> interpreted =
interpretAsModifierWrappingCall((PyCallExpression) value, this);
if (interpreted != null) {
PyFunction original = interpreted.getSecond();
if (original == this) {
String wrapper_name = interpreted.getFirst();
if (PyNames.CLASSMETHOD.equals(wrapper_name)) {
return CLASSMETHOD;
} else if (PyNames.STATICMETHOD.equals(wrapper_name)) {
return STATICMETHOD;
}
}
}
}
}
}
}
}
return null;
}
private static boolean isAbstract(@NotNull PyClass pyClass) {
final PyType metaClass =
pyClass.getMetaClassType(
TypeEvalContext.userInitiated(pyClass.getProject(), pyClass.getContainingFile()));
if (metaClass instanceof PyClassLikeType
&& PyNames.ABC_META_CLASS.equals(metaClass.getName())) {
return true;
}
if (metaClass == null) {
final PyExpression metaClassExpr =
as(pyClass.getMetaClassExpression(), PyReferenceExpression.class);
if (metaClassExpr != null && PyNames.ABC_META_CLASS.equals(metaClassExpr.getName())) {
return true;
}
}
for (PyFunction method : pyClass.getMethods(false)) {
if (PyUtil.isDecoratedAsAbstract(method)) {
return true;
}
}
return false;
}
