add BaseManager.create() typechecking

mypy_django_plugin/config.py

@@ -0,0 +1,21 @@
+from configparser import ConfigParser
+from typing import Optional
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Config:
+    django_settings_module: Optional[str] = None
+    ignore_missing_settings: bool = False
+
+    @classmethod
+    def from_config_file(self, fpath: str) -> 'Config':
+        ini_config = ConfigParser()
+        ini_config.read(fpath)
+        if not ini_config.has_section('mypy_django_plugin'):
+            raise ValueError('Invalid config file: no [mypy_django_plugin] section')
+        return Config(django_settings_module=ini_config.get('mypy_django_plugin', 'django_settings',
+                                                            fallback=None),
+                      ignore_missing_settings=ini_config.get('mypy_django_plugin', 'ignore_missing_settings',
+                                                             fallback=False))

mypy_django_plugin/helpers.py

@@ -1,10 +1,9 @@
 import typing
 from typing import Dict, Optional
 
-from mypy.nodes import Expression, FuncDef, ImportedName, MypyFile, NameExpr, SymbolNode, TypeInfo, Var, AssignmentStmt, \
-    CallExpr
+from mypy.nodes import Expression, ImportedName, MypyFile, NameExpr, SymbolNode, TypeInfo
 from mypy.plugin import FunctionContext
-from mypy.types import AnyType, CallableType, Instance, Type, TypeOfAny, TypeVarType, UnionType
+from mypy.types import AnyType, Instance, Type, TypeOfAny, TypeVarType
 
 MODEL_CLASS_FULLNAME = 'django.db.models.base.Model'
 FIELD_FULLNAME = 'django.db.models.fields.Field'
@@ -119,74 +118,6 @@ def fill_typevars(tp: Instance, type_to_fill: Instance) -> Instance:
     return reparametrize_with(type_to_fill, typevar_values)
 
 
-def extract_field_setter_type(tp: Instance) -> Optional[Type]:
-    if tp.type.has_base(FIELD_FULLNAME):
-        set_method = tp.type.get_method('__set__')
-        if isinstance(set_method, FuncDef) and isinstance(set_method.type, CallableType):
-            if 'value' in set_method.type.arg_names:
-                set_value_type = set_method.type.arg_types[set_method.type.arg_names.index('value')]
-                if isinstance(set_value_type, Instance):
-                    set_value_type = fill_typevars(tp, set_value_type)
-                    return set_value_type
-                elif isinstance(set_value_type, UnionType):
-                    items_no_typevars = []
-                    for item in set_value_type.items:
-                        if isinstance(item, Instance):
-                            item = fill_typevars(tp, item)
-                        items_no_typevars.append(item)
-                    return UnionType(items_no_typevars)
-
-        get_method = tp.type.get_method('__get__')
-        if isinstance(get_method, FuncDef) and isinstance(get_method.type, CallableType):
-            return get_method.type.ret_type
-    # GenericForeignKey
-    if tp.type.has_base(GENERIC_FOREIGN_KEY_FULLNAME):
-        return AnyType(TypeOfAny.special_form)
-    return None
-
-
-def extract_primary_key_type(model: TypeInfo) -> Optional[Type]:
-    # only primary keys defined in current class for now
-    for stmt in model.defn.defs.body:
-        if isinstance(stmt, AssignmentStmt) and isinstance(stmt.rvalue, CallExpr):
-            name_expr = stmt.lvalues[0]
-            if isinstance(name_expr, NameExpr):
-                name = name_expr.name
-                if 'primary_key' in stmt.rvalue.arg_names:
-                    is_primary_key = stmt.rvalue.args[stmt.rvalue.arg_names.index('primary_key')]
-                    if is_primary_key:
-                        return extract_field_setter_type(model.names[name].type)
-    return None
-
-
-def extract_expected_types(ctx: FunctionContext, model: TypeInfo) -> Dict[str, Type]:
-    expected_types: Dict[str, Type] = {}
-
-    primary_key_type = extract_primary_key_type(model)
-    if not primary_key_type:
-        # no explicit primary key, set pk to Any and add id
-        primary_key_type = AnyType(TypeOfAny.special_form)
-        expected_types['id'] = ctx.api.named_generic_type('builtins.int', [])
-
-    expected_types['pk'] = primary_key_type
-
-    for base in model.mro:
-        for name, sym in base.names.items():
-            if isinstance(sym.node, Var) and isinstance(sym.node.type, Instance):
-                tp = sym.node.type
-                field_type = extract_field_setter_type(tp)
-                if tp.type.fullname() in {FOREIGN_KEY_FULLNAME, ONETOONE_FIELD_FULLNAME}:
-                    ref_to_model = tp.args[0]
-                    if isinstance(ref_to_model, Instance) and ref_to_model.type.has_base(MODEL_CLASS_FULLNAME):
-                        primary_key_type = extract_primary_key_type(ref_to_model.type)
-                        if not primary_key_type:
-                            primary_key_type = AnyType(TypeOfAny.special_form)
-                        expected_types[name + '_id'] = primary_key_type
-                if field_type:
-                    expected_types[name] = field_type
-    return expected_types
-
-
 def get_argument_by_name(ctx: FunctionContext, name: str) -> Optional[Expression]:
     """Return the expression for the specific argument.
 

mypy_django_plugin/main.py

@@ -1,8 +1,6 @@
 import os
-from configparser import ConfigParser
-from typing import Callable, Dict, Optional, Set, cast
+from typing import Callable, Dict, Optional, cast
 
-from dataclasses import dataclass
 from mypy.checker import TypeChecker
 from mypy.nodes import TypeInfo
 from mypy.options import Options
@@ -10,7 +8,9 @@ from mypy.plugin import ClassDefContext, FunctionContext, MethodContext, Plugin
 from mypy.types import Instance, Type
 
 from mypy_django_plugin import helpers, monkeypatch
-from mypy_django_plugin.plugins.fields import determine_type_of_array_field
+from mypy_django_plugin.config import Config
+from mypy_django_plugin.plugins.fields import determine_type_of_array_field, record_field_properties_into_outer_model_class
+from mypy_django_plugin.plugins.init_create import redefine_and_typecheck_model_init, redefine_and_typecheck_model_create
 from mypy_django_plugin.plugins.migrations import determine_model_cls_from_string_for_migrations
 from mypy_django_plugin.plugins.models import process_model_class
 from mypy_django_plugin.plugins.related_fields import extract_to_parameter_as_get_ret_type_for_related_field, reparametrize_with
@@ -56,81 +56,6 @@ def determine_proper_manager_type(ctx: FunctionContext) -> Type:
     return ret
 
 
-def extract_base_pointer_args(model: TypeInfo) -> Set[str]:
-    pointer_args: Set[str] = set()
-    for base in model.bases:
-        if base.type.has_base(helpers.MODEL_CLASS_FULLNAME):
-            parent_name = base.type.name().lower()
-            pointer_args.add(f'{parent_name}_ptr')
-            pointer_args.add(f'{parent_name}_ptr_id')
-    return pointer_args
-
-
-def redefine_model_init(ctx: FunctionContext) -> Type:
-    assert isinstance(ctx.default_return_type, Instance)
-
-    api = cast(TypeChecker, ctx.api)
-    model: TypeInfo = ctx.default_return_type.type
-
-    expected_types = helpers.extract_expected_types(ctx, model)
-    # order is preserved, can use for positionals
-    positional_names = list(expected_types.keys())
-    positional_names.remove('pk')
-    visited_positionals = set()
-
-    # check positionals
-    for i, (_, actual_pos_type) in enumerate(zip(ctx.arg_names[0], ctx.arg_types[0])):
-        actual_pos_name = positional_names[i]
-        api.check_subtype(actual_pos_type, expected_types[actual_pos_name],
-                          ctx.context,
-                          'Incompatible type for "{}" of "{}"'.format(actual_pos_name,
-                                                                      model.name()),
-                          'got', 'expected')
-        visited_positionals.add(actual_pos_name)
-
-    # extract name of base models for _ptr
-    base_pointer_args = extract_base_pointer_args(model)
-
-    # check kwargs
-    for i, (actual_name, actual_type) in enumerate(zip(ctx.arg_names[1], ctx.arg_types[1])):
-        if actual_name in base_pointer_args:
-            # parent_ptr args are not supported
-            continue
-        if actual_name in visited_positionals:
-            continue
-        if actual_name is None:
-            # unpacked dict as kwargs is not supported
-            continue
-        if actual_name not in expected_types:
-            ctx.api.fail('Unexpected attribute "{}" for model "{}"'.format(actual_name,
-                                                                           model.name()),
-                         ctx.context)
-            continue
-        api.check_subtype(actual_type, expected_types[actual_name],
-                          ctx.context,
-                          'Incompatible type for "{}" of "{}"'.format(actual_name,
-                                                                      model.name()),
-                          'got', 'expected')
-    return ctx.default_return_type
-
-
-@dataclass
-class Config:
-    django_settings_module: Optional[str] = None
-    ignore_missing_settings: bool = False
-
-    @classmethod
-    def from_config_file(self, fpath: str) -> 'Config':
-        ini_config = ConfigParser()
-        ini_config.read(fpath)
-        if not ini_config.has_section('mypy_django_plugin'):
-            raise ValueError('Invalid config file: no [mypy_django_plugin] section')
-        return Config(django_settings_module=ini_config.get('mypy_django_plugin', 'django_settings',
-                                                            fallback=None),
-                      ignore_missing_settings=ini_config.get('mypy_django_plugin', 'ignore_missing_settings',
-                                                             fallback=False))
-
-
 class DjangoPlugin(Plugin):
     def __init__(self, options: Options) -> None:
         super().__init__(options)
@@ -194,11 +119,18 @@ class DjangoPlugin(Plugin):
 
         sym = self.lookup_fully_qualified(fullname)
         if sym and isinstance(sym.node, TypeInfo):
+            if sym.node.has_base(helpers.FIELD_FULLNAME):
+                return record_field_properties_into_outer_model_class
             if sym.node.metadata.get('django', {}).get('generated_init'):
-                return redefine_model_init
+                return redefine_and_typecheck_model_init
 
     def get_method_hook(self, fullname: str
                         ) -> Optional[Callable[[MethodContext], Type]]:
+        manager_classes = self._get_current_manager_bases()
+        class_fullname, _, method_name = fullname.rpartition('.')
+        if class_fullname in manager_classes and method_name == 'create':
+            return redefine_and_typecheck_model_create
+
         if fullname in {'django.apps.registry.Apps.get_model',
                         'django.db.migrations.state.StateApps.get_model'}:
             return determine_model_cls_from_string_for_migrations

mypy_django_plugin/plugins/fields.py

@@ -1,7 +1,12 @@
+from typing import cast
+
+from mypy.checker import TypeChecker
+from mypy.nodes import ListExpr, NameExpr, TupleExpr
 from mypy.plugin import FunctionContext
-from mypy.types import Type, Instance
+from mypy.types import Instance, TupleType, Type
 
 from mypy_django_plugin import helpers
+from mypy_django_plugin.plugins.models import iter_over_assignments
 
 
 def determine_type_of_array_field(ctx: FunctionContext) -> Type:
@@ -16,3 +21,54 @@ def determine_type_of_array_field(ctx: FunctionContext) -> Type:
 
     return ctx.api.named_generic_type(ctx.context.callee.fullname,
                                       args=[get_method.type.ret_type])
+
+
+def record_field_properties_into_outer_model_class(ctx: FunctionContext) -> Type:
+    api = cast(TypeChecker, ctx.api)
+    outer_model = api.scope.active_class()
+    if outer_model is None or not outer_model.has_base(helpers.MODEL_CLASS_FULLNAME):
+        # outside models.Model class, undetermined
+        return ctx.default_return_type
+
+    field_name = None
+    for name_expr, stmt in iter_over_assignments(outer_model.defn):
+        if stmt == ctx.context and isinstance(name_expr, NameExpr):
+            field_name = name_expr.name
+            break
+    if field_name is None:
+        return ctx.default_return_type
+
+    fields_metadata = outer_model.metadata.setdefault('django', {}).setdefault('fields', {})
+
+    # primary key
+    is_primary_key = False
+    primary_key_arg = helpers.get_argument_by_name(ctx, 'primary_key')
+    if primary_key_arg:
+        is_primary_key = helpers.parse_bool(primary_key_arg)
+    fields_metadata[field_name] = {'primary_key': is_primary_key}
+
+    # choices
+    choices_arg = helpers.get_argument_by_name(ctx, 'choices')
+    if choices_arg and isinstance(choices_arg, (TupleExpr, ListExpr)):
+        # iterable of 2 element tuples of two kinds
+        _, analyzed_choices = api.analyze_iterable_item_type(choices_arg)
+        if isinstance(analyzed_choices, TupleType):
+            first_element_type = analyzed_choices.items[0]
+            if isinstance(first_element_type, Instance):
+                fields_metadata[field_name]['choices'] = first_element_type.type.fullname()
+
+    # nullability
+    null_arg = helpers.get_argument_by_name(ctx, 'null')
+    is_nullable = False
+    if null_arg:
+        is_nullable = helpers.parse_bool(null_arg)
+    fields_metadata[field_name]['null'] = is_nullable
+
+    # is_blankable
+    blank_arg = helpers.get_argument_by_name(ctx, 'blank')
+    is_blankable = False
+    if blank_arg:
+        is_blankable = helpers.parse_bool(blank_arg)
+    fields_metadata[field_name]['blank'] = is_blankable
+
+    return ctx.default_return_type

mypy_django_plugin/plugins/init_create.py

@@ -0,0 +1,182 @@
+from typing import Dict, Optional, Set, cast, Any
+
+from mypy.checker import TypeChecker
+from mypy.nodes import FuncDef, TypeInfo, Var
+from mypy.plugin import FunctionContext, MethodContext
+from mypy.types import AnyType, CallableType, Instance, Type, TypeOfAny, UnionType
+
+from mypy_django_plugin import helpers
+
+
+def extract_base_pointer_args(model: TypeInfo) -> Set[str]:
+    pointer_args: Set[str] = set()
+    for base in model.bases:
+        if base.type.has_base(helpers.MODEL_CLASS_FULLNAME):
+            parent_name = base.type.name().lower()
+            pointer_args.add(f'{parent_name}_ptr')
+            pointer_args.add(f'{parent_name}_ptr_id')
+    return pointer_args
+
+
+def redefine_and_typecheck_model_init(ctx: FunctionContext) -> Type:
+    assert isinstance(ctx.default_return_type, Instance)
+
+    api = cast(TypeChecker, ctx.api)
+    model: TypeInfo = ctx.default_return_type.type
+
+    expected_types = extract_expected_types(ctx, model)
+    # order is preserved, can use for positionals
+    positional_names = list(expected_types.keys())
+    positional_names.remove('pk')
+    visited_positionals = set()
+
+    # check positionals
+    for i, (_, actual_pos_type) in enumerate(zip(ctx.arg_names[0], ctx.arg_types[0])):
+        actual_pos_name = positional_names[i]
+        api.check_subtype(actual_pos_type, expected_types[actual_pos_name],
+                          ctx.context,
+                          'Incompatible type for "{}" of "{}"'.format(actual_pos_name,
+                                                                      model.name()),
+                          'got', 'expected')
+        visited_positionals.add(actual_pos_name)
+
+    # extract name of base models for _ptr
+    base_pointer_args = extract_base_pointer_args(model)
+
+    # check kwargs
+    for i, (actual_name, actual_type) in enumerate(zip(ctx.arg_names[1], ctx.arg_types[1])):
+        if actual_name in base_pointer_args:
+            # parent_ptr args are not supported
+            continue
+        if actual_name in visited_positionals:
+            continue
+        if actual_name is None:
+            # unpacked dict as kwargs is not supported
+            continue
+        if actual_name not in expected_types:
+            ctx.api.fail('Unexpected attribute "{}" for model "{}"'.format(actual_name,
+                                                                           model.name()),
+                         ctx.context)
+            continue
+        api.check_subtype(actual_type, expected_types[actual_name],
+                          ctx.context,
+                          'Incompatible type for "{}" of "{}"'.format(actual_name,
+                                                                      model.name()),
+                          'got', 'expected')
+    return ctx.default_return_type
+
+
+def redefine_and_typecheck_model_create(ctx: MethodContext) -> Type:
+    api = cast(TypeChecker, ctx.api)
+    if isinstance(ctx.type, Instance) and len(ctx.type.args) > 0:
+        model: TypeInfo = ctx.type.args[0].type
+    else:
+        if isinstance(ctx.default_return_type, AnyType):
+            return ctx.default_return_type
+        model: TypeInfo = ctx.default_return_type.type
+
+    # extract name of base models for _ptr
+    base_pointer_args = extract_base_pointer_args(model)
+    expected_types = extract_expected_types(ctx, model)
+
+    for actual_name, actual_type in zip(ctx.arg_names[0], ctx.arg_types[0]):
+        if actual_name in base_pointer_args:
+            # parent_ptr args are not supported
+            continue
+        if actual_name is None:
+            # unpacked dict as kwargs is not supported
+            continue
+        if actual_name not in expected_types:
+            api.fail('Unexpected attribute "{}" for model "{}"'.format(actual_name,
+                                                                       model.name()),
+                     ctx.context)
+            continue
+        api.check_subtype(actual_type, expected_types[actual_name],
+                          ctx.context,
+                          'Incompatible type for "{}" of "{}"'.format(actual_name,
+                                                                      model.name()),
+                          'got', 'expected')
+
+    return ctx.default_return_type
+
+
+def extract_field_setter_type(tp: Instance) -> Optional[Type]:
+    if not isinstance(tp, Instance):
+        return None
+    if tp.type.has_base(helpers.FIELD_FULLNAME):
+        set_method = tp.type.get_method('__set__')
+        if isinstance(set_method, FuncDef) and isinstance(set_method.type, CallableType):
+            if 'value' in set_method.type.arg_names:
+                set_value_type = set_method.type.arg_types[set_method.type.arg_names.index('value')]
+                if isinstance(set_value_type, Instance):
+                    set_value_type = helpers.fill_typevars(tp, set_value_type)
+                    return set_value_type
+                elif isinstance(set_value_type, UnionType):
+                    items_no_typevars = []
+                    for item in set_value_type.items:
+                        if isinstance(item, Instance):
+                            item = helpers.fill_typevars(tp, item)
+                        items_no_typevars.append(item)
+                    return UnionType(items_no_typevars)
+
+        get_method = tp.type.get_method('__get__')
+        if isinstance(get_method, FuncDef) and isinstance(get_method.type, CallableType):
+            return get_method.type.ret_type
+    # GenericForeignKey
+    if tp.type.has_base(helpers.GENERIC_FOREIGN_KEY_FULLNAME):
+        return AnyType(TypeOfAny.special_form)
+    return None
+
+
+def get_fields_metadata(model: TypeInfo) -> Dict[str, Any]:
+    return model.metadata.setdefault('django', {}).setdefault('fields', {})
+
+
+def extract_primary_key_type(model: TypeInfo) -> Optional[Type]:
+    for field_name, props in get_fields_metadata(model).items():
+        is_primary_key = props.get('primary_key', False)
+        if is_primary_key:
+            return extract_field_setter_type(model.names[field_name].type)
+    return None
+
+
+def extract_choices_type(model: TypeInfo, field_name: str) -> Optional[str]:
+    field_metadata = get_fields_metadata(model).get(field_name, {})
+    if 'choices' in field_metadata:
+        return field_metadata['choices']
+    return None
+
+
+def extract_expected_types(ctx: FunctionContext, model: TypeInfo) -> Dict[str, Type]:
+    expected_types: Dict[str, Type] = {}
+
+    primary_key_type = extract_primary_key_type(model)
+    if not primary_key_type:
+        # no explicit primary key, set pk to Any and add id
+        primary_key_type = AnyType(TypeOfAny.special_form)
+        expected_types['id'] = ctx.api.named_generic_type('builtins.int', [])
+
+    expected_types['pk'] = primary_key_type
+
+    for base in model.mro:
+        for name, sym in base.names.items():
+            if isinstance(sym.node, Var) and isinstance(sym.node.type, Instance):
+                tp = sym.node.type
+                field_type = extract_field_setter_type(tp)
+                if field_type is None:
+                    continue
+
+                choices_type_fullname = extract_choices_type(model, name)
+                if choices_type_fullname:
+                    field_type = UnionType([field_type, ctx.api.named_generic_type(choices_type_fullname, [])])
+
+                if tp.type.fullname() in {helpers.FOREIGN_KEY_FULLNAME, helpers.ONETOONE_FIELD_FULLNAME}:
+                    ref_to_model = tp.args[0]
+                    if isinstance(ref_to_model, Instance) and ref_to_model.type.has_base(helpers.MODEL_CLASS_FULLNAME):
+                        primary_key_type = extract_primary_key_type(ref_to_model.type)
+                        if not primary_key_type:
+                            primary_key_type = AnyType(TypeOfAny.special_form)
+                        expected_types[name + '_id'] = primary_key_type
+                if field_type:
+                    expected_types[name] = field_type
+    return expected_types

mypy_django_plugin/plugins/migrations.py

@@ -1,9 +1,9 @@
-from typing import cast, Optional
+from typing import Optional, cast
 
 from mypy.checker import TypeChecker
-from mypy.nodes import TypeInfo, Expression, StrExpr, NameExpr, RefExpr, Var
+from mypy.nodes import Expression, StrExpr, TypeInfo
 from mypy.plugin import MethodContext
-from mypy.types import Type, Instance, TypeType
+from mypy.types import Instance, Type, TypeType
 
 from mypy_django_plugin import helpers
 

mypy_django_plugin/plugins/models.py

@@ -1,13 +1,13 @@
 from abc import ABCMeta, abstractmethod
-from typing import Dict, Iterator, Optional, Tuple, cast
+from typing import Dict, Iterator, List, Optional, Tuple, cast
 
 import dataclasses
-from mypy.nodes import AssignmentStmt, CallExpr, ClassDef, Context, Expression, Lvalue, MDEF, MemberExpr, \
-    MypyFile, NameExpr, StrExpr, SymbolTableNode, TypeInfo, Var, Argument, ARG_STAR2, ARG_STAR
+from mypy.nodes import ARG_STAR, ARG_STAR2, Argument, AssignmentStmt, CallExpr, ClassDef, Context, Expression, IndexExpr, \
+    Lvalue, MDEF, MemberExpr, MypyFile, NameExpr, StrExpr, SymbolTableNode, TypeInfo, Var
 from mypy.plugin import ClassDefContext
 from mypy.plugins.common import add_method
 from mypy.semanal import SemanticAnalyzerPass2
-from mypy.types import Instance, AnyType, TypeOfAny, NoneTyp
+from mypy.types import AnyType, Instance, NoneTyp, TypeOfAny
 
 from mypy_django_plugin import helpers
 
@@ -27,18 +27,20 @@ class ModelClassInitializer(metaclass=ABCMeta):
             return metaclass_sym.node
         return None
 
-    def is_abstract_model(self) -> bool:
+    def get_meta_attribute(self, name: str) -> Optional[Expression]:
         meta_node = self.get_nested_meta_node()
         if meta_node is None:
-            return False
+            return None
 
         for lvalue, rvalue in iter_over_assignments(meta_node.defn):
-            if isinstance(lvalue, NameExpr) and lvalue.name == 'abstract':
-                is_abstract = self.api.parse_bool(rvalue)
-                if is_abstract:
-                    # abstract model do not need 'objects' queryset
-                    return True
-        return False
+            if isinstance(lvalue, NameExpr) and lvalue.name == name:
+                return rvalue
+
+    def is_abstract_model(self) -> bool:
+        is_abstract_expr = self.get_meta_attribute('abstract')
+        if is_abstract_expr is None:
+            return False
+        return self.api.parse_bool(is_abstract_expr)
 
     def add_new_node_to_model_class(self, name: str, typ: Instance) -> None:
         var = Var(name=name, type=typ)
@@ -93,25 +95,65 @@ class InjectAnyAsBaseForNestedMeta(ModelClassInitializer):
         meta_node.fallback_to_any = True
 
 
+def get_model_argument(manager_info: TypeInfo) -> Optional[Instance]:
+    for base in manager_info.bases:
+        if base.args:
+            model_arg = base.args[0]
+            if isinstance(model_arg, Instance) and model_arg.type.has_base(helpers.MODEL_CLASS_FULLNAME):
+                return model_arg
+    return None
+
+
 class AddDefaultObjectsManager(ModelClassInitializer):
-    def is_default_objects_attr(self, sym: SymbolTableNode) -> bool:
-        return sym.fullname == helpers.MODEL_CLASS_FULLNAME + '.' + 'objects'
+    def add_new_manager(self, name: str, manager_type: Optional[Instance]) -> None:
+        if manager_type is None:
+            return None
+        self.add_new_node_to_model_class(name, manager_type)
+
+    def add_private_default_manager(self, manager_type: Optional[Instance]) -> None:
+        if manager_type is None:
+            return None
+        self.add_new_node_to_model_class('_default_manager', manager_type)
+
+    def get_existing_managers(self) -> List[Tuple[str, TypeInfo]]:
+        managers = []
+        for base in self.model_classdef.info.mro:
+            for name_expr, member_expr in iter_call_assignments(base.defn):
+                manager_name = name_expr.name
+                callee_expr = member_expr.callee
+                if isinstance(callee_expr, IndexExpr):
+                    callee_expr = callee_expr.analyzed.expr
+                if isinstance(callee_expr, (MemberExpr, NameExpr)) \
+                    and isinstance(callee_expr.node, TypeInfo) \
+                    and callee_expr.node.has_base(helpers.BASE_MANAGER_CLASS_FULLNAME):
+                    managers.append((manager_name, callee_expr.node))
+        return managers
 
     def run(self) -> None:
-        existing_objects_sym = self.model_classdef.info.get('objects')
-        if (existing_objects_sym is not None
-            and not self.is_default_objects_attr(existing_objects_sym)):
-            return None
+        existing_managers = self.get_existing_managers()
+        if existing_managers:
+            first_manager_type = None
+            for manager_name, manager_type_info in existing_managers:
+                manager_type = Instance(manager_type_info, args=[Instance(self.model_classdef.info, [])])
+                self.add_new_manager(name=manager_name, manager_type=manager_type)
+                if first_manager_type is None:
+                    first_manager_type = manager_type
+        else:
+            if self.is_abstract_model():
+                # abstract models do not need 'objects' queryset
+                return None
+
+            first_manager_type = self.api.named_type_or_none(helpers.MANAGER_CLASS_FULLNAME,
+                                                             args=[Instance(self.model_classdef.info, [])])
+            self.add_new_manager('objects', manager_type=first_manager_type)
 
         if self.is_abstract_model():
-            # abstract models do not need 'objects' queryset
             return None
-
-        typ = self.api.named_type_or_none(helpers.MANAGER_CLASS_FULLNAME,
-                                          args=[Instance(self.model_classdef.info, [])])
-        if not typ:
-            return None
-        self.add_new_node_to_model_class('objects', typ)
+        default_manager_name_expr = self.get_meta_attribute('default_manager_name')
+        if isinstance(default_manager_name_expr, StrExpr):
+            self.add_private_default_manager(self.model_classdef.info.get(default_manager_name_expr.value).type)
+        else:
+            self.add_private_default_manager(first_manager_type)
 
 
 class AddIdAttributeIfPrimaryKeyTrueIsNotSet(ModelClassInitializer):