refactor, fix method copying

mypy_django_plugin/transformers/fields.py

@@ -9,13 +9,13 @@ from mypy.types import Type as MypyType
 from mypy.types import TypeOfAny
 
 from mypy_django_plugin.django.context import DjangoContext
-from mypy_django_plugin.lib import fullnames, helpers
+from mypy_django_plugin.lib import fullnames, helpers, chk_helpers
 
 
 def _get_current_field_from_assignment(ctx: FunctionContext, django_context: DjangoContext) -> Optional[Field]:
-    outer_model_info = helpers.get_typechecker_api(ctx).scope.active_class()
+    outer_model_info = chk_helpers.get_typechecker_api(ctx).scope.active_class()
     if (outer_model_info is None
-            or not helpers.is_model_subclass_info(outer_model_info, django_context)):
+            or not helpers.is_subclass_of_model(outer_model_info, django_context)):
         return None
 
     field_name = None
@@ -66,21 +66,21 @@ def fill_descriptor_types_for_related_field(ctx: FunctionContext, django_context
         # __get__/__set__ of ForeignKey of derived model
         for model_cls in django_context.all_registered_model_classes:
             if issubclass(model_cls, current_model_cls) and not model_cls._meta.abstract:
-                derived_model_info = helpers.lookup_class_typeinfo(helpers.get_typechecker_api(ctx), model_cls)
+                derived_model_info = helpers.lookup_class_typeinfo(chk_helpers.get_typechecker_api(ctx), model_cls)
                 if derived_model_info is not None:
                     fk_ref_type = Instance(derived_model_info, [])
                     derived_fk_type = reparametrize_related_field_type(default_related_field_type,
                                                                        set_type=fk_ref_type, get_type=fk_ref_type)
-                    helpers.add_new_sym_for_info(derived_model_info,
-                                                 name=current_field.name,
-                                                 sym_type=derived_fk_type)
+                    chk_helpers.add_new_sym_for_info(derived_model_info,
+                                                     name=current_field.name,
+                                                     sym_type=derived_fk_type)
 
     related_model = related_model_cls
     related_model_to_set = related_model_cls
     if related_model_to_set._meta.proxy_for_model is not None:
         related_model_to_set = related_model_to_set._meta.proxy_for_model
 
-    typechecker_api = helpers.get_typechecker_api(ctx)
+    typechecker_api = chk_helpers.get_typechecker_api(ctx)
 
     related_model_info = helpers.lookup_class_typeinfo(typechecker_api, related_model)
     if related_model_info is None:
@@ -114,7 +114,7 @@ def set_descriptor_types_for_field(ctx: FunctionContext) -> Instance:
     default_return_type = cast(Instance, ctx.default_return_type)
 
     is_nullable = False
-    null_expr = helpers.get_call_argument_by_name(ctx, 'null')
+    null_expr = chk_helpers.get_call_argument_by_name(ctx, 'null')
     if null_expr is not None:
         is_nullable = helpers.parse_bool(null_expr) or False
 
@@ -122,10 +122,10 @@ def set_descriptor_types_for_field(ctx: FunctionContext) -> Instance:
     return helpers.reparametrize_instance(default_return_type, [set_type, get_type])
 
 
-def determine_type_of_array_field(ctx: FunctionContext, django_context: DjangoContext) -> MypyType:
+def determine_type_of_array_field(ctx: FunctionContext) -> MypyType:
     default_return_type = set_descriptor_types_for_field(ctx)
 
-    base_field_arg_type = helpers.get_call_argument_type_by_name(ctx, 'base_field')
+    base_field_arg_type = chk_helpers.get_call_argument_type_by_name(ctx, 'base_field')
     if not base_field_arg_type or not isinstance(base_field_arg_type, Instance):
         return default_return_type
 
@@ -141,9 +141,9 @@ def transform_into_proper_return_type(ctx: FunctionContext, django_context: Djan
     default_return_type = ctx.default_return_type
     assert isinstance(default_return_type, Instance)
 
-    outer_model_info = helpers.get_typechecker_api(ctx).scope.active_class()
+    outer_model_info = chk_helpers.get_typechecker_api(ctx).scope.active_class()
     if (outer_model_info is None
-            or not helpers.is_model_subclass_info(outer_model_info, django_context)):
+            or not helpers.is_subclass_of_model(outer_model_info, django_context)):
         return ctx.default_return_type
 
     assert isinstance(outer_model_info, TypeInfo)
@@ -152,6 +152,6 @@ def transform_into_proper_return_type(ctx: FunctionContext, django_context: Djan
         return fill_descriptor_types_for_related_field(ctx, django_context)
 
     if default_return_type.type.has_base(fullnames.ARRAY_FIELD_FULLNAME):
-        return determine_type_of_array_field(ctx, django_context)
+        return determine_type_of_array_field(ctx)
 
     return set_descriptor_types_for_field(ctx)

mypy_django_plugin/transformers/forms.py

@@ -5,11 +5,11 @@ from mypy.types import CallableType, Instance, NoneTyp
 from mypy.types import Type as MypyType
 from mypy.types import TypeType
 
-from mypy_django_plugin.lib import helpers
+from mypy_django_plugin.lib import sem_helpers, chk_helpers
 
 
 def make_meta_nested_class_inherit_from_any(ctx: ClassDefContext) -> None:
-    meta_node = helpers.get_nested_meta_node_for_current_class(ctx.cls.info)
+    meta_node = sem_helpers.get_nested_meta_node_for_current_class(ctx.cls.info)
     if meta_node is None:
         if not ctx.api.final_iteration:
             ctx.api.defer()
@@ -28,7 +28,7 @@ def extract_proper_type_for_get_form(ctx: MethodContext) -> MypyType:
     object_type = ctx.type
     assert isinstance(object_type, Instance)
 
-    form_class_type = helpers.get_call_argument_type_by_name(ctx, 'form_class')
+    form_class_type = chk_helpers.get_call_argument_type_by_name(ctx, 'form_class')
     if form_class_type is None or isinstance(form_class_type, NoneTyp):
         form_class_type = get_specified_form_class(object_type)
 

mypy_django_plugin/transformers/init_create.py

@@ -6,7 +6,7 @@ from mypy.types import Instance
 from mypy.types import Type as MypyType
 
 from mypy_django_plugin.django.context import DjangoContext
-from mypy_django_plugin.lib import helpers
+from mypy_django_plugin.lib import chk_helpers
 
 
 def get_actual_types(ctx: Union[MethodContext, FunctionContext],
@@ -32,7 +32,7 @@ def get_actual_types(ctx: Union[MethodContext, FunctionContext],
 
 def typecheck_model_method(ctx: Union[FunctionContext, MethodContext], django_context: DjangoContext,
                            model_cls: Type[Model], method: str) -> MypyType:
-    typechecker_api = helpers.get_typechecker_api(ctx)
+    typechecker_api = chk_helpers.get_typechecker_api(ctx)
     expected_types = django_context.get_expected_types(typechecker_api, model_cls, method=method)
     expected_keys = [key for key in expected_types.keys() if key != 'pk']
 
@@ -42,11 +42,11 @@ def typecheck_model_method(ctx: Union[FunctionContext, MethodContext], django_co
                                                                            model_cls.__name__),
                          ctx.context)
             continue
-        helpers.check_types_compatible(ctx,
-                                       expected_type=expected_types[actual_name],
-                                       actual_type=actual_type,
-                                       error_message='Incompatible type for "{}" of "{}"'.format(actual_name,
-                                                                                                 model_cls.__name__))
+        error_message = 'Incompatible type for "{}" of "{}"'.format(actual_name, model_cls.__name__)
+        chk_helpers.check_types_compatible(ctx,
+                                           expected_type=expected_types[actual_name],
+                                           actual_type=actual_type,
+                                           error_message=error_message)
 
     return ctx.default_return_type
 

mypy_django_plugin/transformers/managers.py

@@ -1,77 +1,149 @@
+from typing import Iterator, Tuple, Optional
+
 from mypy.nodes import (
-    GDEF, FuncDef, MemberExpr, NameExpr, RefExpr, StrExpr, SymbolTableNode, TypeInfo,
+    FuncDef, MemberExpr, NameExpr, RefExpr, StrExpr, TypeInfo,
+    PlaceholderNode, SymbolTableNode, GDEF
 )
 from mypy.plugin import ClassDefContext, DynamicClassDefContext
 from mypy.types import AnyType, Instance, TypeOfAny
+from mypy.typevars import fill_typevars
 
-from mypy_django_plugin.lib import fullnames, helpers
+from mypy_django_plugin.lib import fullnames, sem_helpers, helpers
 
 
-def create_new_manager_class_from_from_queryset_method(ctx: DynamicClassDefContext) -> None:
-    semanal_api = helpers.get_semanal_api(ctx)
+def iter_all_custom_queryset_methods(derived_queryset_info: TypeInfo) -> Iterator[Tuple[str, FuncDef]]:
+    for base_queryset_info in derived_queryset_info.mro:
+        if base_queryset_info.fullname == fullnames.QUERYSET_CLASS_FULLNAME:
+            break
+        for name, sym in base_queryset_info.names.items():
+            if isinstance(sym.node, FuncDef):
+                yield name, sym.node
 
+
+def resolve_callee_manager_info_or_exception(ctx: DynamicClassDefContext) -> Optional[TypeInfo]:
     callee = ctx.call.callee
     assert isinstance(callee, MemberExpr)
     assert isinstance(callee.expr, RefExpr)
 
-    base_manager_info = callee.expr.node
-    if base_manager_info is None:
-        if not semanal_api.final_iteration:
-            semanal_api.defer()
-        return
+    callee_manager_info = callee.expr.node
+    if (callee_manager_info is None
+            or isinstance(callee_manager_info, PlaceholderNode)):
+        raise sem_helpers.IncompleteDefnException(f'Definition of base manager {callee_manager_info.fullname} '
+                                                  f'is incomplete.')
 
-    assert isinstance(base_manager_info, TypeInfo)
-    new_manager_info = semanal_api.basic_new_typeinfo(ctx.name,
-                                                      basetype_or_fallback=Instance(base_manager_info,
-                                                                                    [AnyType(TypeOfAny.unannotated)]))
-    new_manager_info.line = ctx.call.line
-    new_manager_info.defn.line = ctx.call.line
-    new_manager_info.metaclass_type = new_manager_info.calculate_metaclass_type()
+    assert isinstance(callee_manager_info, TypeInfo)
+    return callee_manager_info
 
-    current_module = semanal_api.cur_mod_node
-    current_module.names[ctx.name] = SymbolTableNode(GDEF, new_manager_info,
-                                                     plugin_generated=True)
-    passed_queryset = ctx.call.args[0]
-    assert isinstance(passed_queryset, NameExpr)
 
-    derived_queryset_fullname = passed_queryset.fullname
-    assert derived_queryset_fullname is not None
+def resolve_passed_queryset_info_or_exception(ctx: DynamicClassDefContext) -> Optional[TypeInfo]:
+    api = sem_helpers.get_semanal_api(ctx)
 
-    sym = semanal_api.lookup_fully_qualified_or_none(derived_queryset_fullname)
-    assert sym is not None
-    if sym.node is None:
-        if not semanal_api.final_iteration:
-            semanal_api.defer()
-        else:
-            # inherit from Any to prevent false-positives, if queryset class cannot be resolved
-            new_manager_info.fallback_to_any = True
-        return
+    passed_queryset_name_expr = ctx.call.args[0]
+    assert isinstance(passed_queryset_name_expr, NameExpr)
 
-    derived_queryset_info = sym.node
-    assert isinstance(derived_queryset_info, TypeInfo)
+    sym = api.lookup_qualified(passed_queryset_name_expr.name, ctx=ctx.call)
+    if (sym is None
+            or sym.node is None
+            or isinstance(sym.node, PlaceholderNode)):
+        raise sem_helpers.BoundNameNotFound(passed_queryset_name_expr.fullname)
 
+    assert isinstance(sym.node, TypeInfo)
+    return sym.node
+
+
+def resolve_django_manager_info_or_exception(ctx: DynamicClassDefContext) -> Optional[TypeInfo]:
+    api = sem_helpers.get_semanal_api(ctx)
+
+    sym = api.lookup_fully_qualified_or_none(fullnames.MANAGER_CLASS_FULLNAME)
+    if (sym is None
+            or sym.node is None
+            or isinstance(sym.node, PlaceholderNode)):
+        raise sem_helpers.BoundNameNotFound(fullnames.MANAGER_CLASS_FULLNAME)
+
+    assert isinstance(sym.node, TypeInfo)
+    return sym.node
+
+
+def new_manager_typeinfo(ctx: DynamicClassDefContext, callee_manager_info: TypeInfo) -> TypeInfo:
+    callee_manager_type = Instance(callee_manager_info, [AnyType(TypeOfAny.unannotated)])
+    api = sem_helpers.get_semanal_api(ctx)
+
+    new_manager_class_name = ctx.name
+    new_manager_info = helpers.new_typeinfo(new_manager_class_name,
+                                            bases=[callee_manager_type], module_name=api.cur_mod_id)
+    new_manager_info.set_line(ctx.call)
+    return new_manager_info
+
+
+def record_new_manager_info_fullname_into_metadata(ctx: DynamicClassDefContext,
+                                                   new_manager_fullname: str,
+                                                   callee_manager_info: TypeInfo,
+                                                   queryset_info: TypeInfo,
+                                                   django_manager_info: TypeInfo) -> None:
     if len(ctx.call.args) > 1:
         expr = ctx.call.args[1]
         assert isinstance(expr, StrExpr)
         custom_manager_generated_name = expr.value
     else:
-        custom_manager_generated_name = base_manager_info.name + 'From' + derived_queryset_info.name
+        custom_manager_generated_name = callee_manager_info.name + 'From' + queryset_info.name
 
-    custom_manager_generated_fullname = '.'.join(['django.db.models.manager', custom_manager_generated_name])
-    if 'from_queryset_managers' not in base_manager_info.metadata:
-        base_manager_info.metadata['from_queryset_managers'] = {}
-    base_manager_info.metadata['from_queryset_managers'][custom_manager_generated_fullname] = new_manager_info.fullname
+    custom_manager_generated_fullname = 'django.db.models.manager' + '.' + custom_manager_generated_name
+
+    metadata = django_manager_info.metadata.setdefault('from_queryset_managers', {})
+    metadata[custom_manager_generated_fullname] = new_manager_fullname
+
+
+def create_new_manager_class_from_from_queryset_method(ctx: DynamicClassDefContext) -> None:
+    semanal_api = sem_helpers.get_semanal_api(ctx)
+    try:
+        callee_manager_info = resolve_callee_manager_info_or_exception(ctx)
+        queryset_info = resolve_passed_queryset_info_or_exception(ctx)
+        django_manager_info = resolve_django_manager_info_or_exception(ctx)
+    except sem_helpers.IncompleteDefnException:
+        if not semanal_api.final_iteration:
+            semanal_api.defer()
+            return
+        else:
+            raise
+
+    new_manager_info = new_manager_typeinfo(ctx, callee_manager_info)
+    record_new_manager_info_fullname_into_metadata(ctx,
+                                                   new_manager_info.fullname,
+                                                   callee_manager_info,
+                                                   queryset_info,
+                                                   django_manager_info)
 
     class_def_context = ClassDefContext(cls=new_manager_info.defn,
                                         reason=ctx.call, api=semanal_api)
-    self_type = Instance(new_manager_info, [])
-    # we need to copy all methods in MRO before django.db.models.query.QuerySet
-    for class_mro_info in derived_queryset_info.mro:
-        if class_mro_info.fullname == fullnames.QUERYSET_CLASS_FULLNAME:
-            break
-        for name, sym in class_mro_info.names.items():
-            if isinstance(sym.node, FuncDef):
-                helpers.copy_method_to_another_class(class_def_context,
-                                                     self_type,
-                                                     new_method_name=name,
-                                                     method_node=sym.node)
+    self_type = fill_typevars(new_manager_info)
+    # self_type = Instance(new_manager_info, [])
+
+    try:
+        for name, method_node in iter_all_custom_queryset_methods(queryset_info):
+            sem_helpers.copy_method_or_incomplete_defn_exception(class_def_context,
+                                                                 self_type,
+                                                                 new_method_name=name,
+                                                                 method_node=method_node)
+    except sem_helpers.IncompleteDefnException:
+        if not semanal_api.final_iteration:
+            semanal_api.defer()
+            return
+        else:
+            raise
+
+    new_manager_sym = SymbolTableNode(GDEF, new_manager_info, plugin_generated=True)
+
+    # context=None - forcibly replace old node
+    added = semanal_api.add_symbol_table_node(ctx.name, new_manager_sym, context=None)
+    if added:
+        # replace all references to the old manager Var everywhere
+        for _, module in semanal_api.modules.items():
+            if module.fullname != semanal_api.cur_mod_id:
+                for sym_name, sym in module.names.items():
+                    if sym.fullname == new_manager_info.fullname:
+                        module.names[sym_name] = new_manager_sym.copy()
+
+    # we need another iteration to process methods
+    if (not added
+            and not semanal_api.final_iteration):
+        semanal_api.defer()

mypy_django_plugin/transformers/meta.py

@@ -5,12 +5,12 @@ from mypy.types import Type as MypyType
 from mypy.types import TypeOfAny
 
 from mypy_django_plugin.django.context import DjangoContext
-from mypy_django_plugin.lib import helpers
+from mypy_django_plugin.lib import helpers, chk_helpers
 
 
 def _get_field_instance(ctx: MethodContext, field_fullname: str) -> MypyType:
-    field_info = helpers.lookup_fully_qualified_typeinfo(helpers.get_typechecker_api(ctx),
-                                                         field_fullname)
+    api = chk_helpers.get_typechecker_api(ctx)
+    field_info = helpers.lookup_fully_qualified_typeinfo(api, field_fullname)
     if field_info is None:
         return AnyType(TypeOfAny.unannotated)
     return Instance(field_info, [AnyType(TypeOfAny.explicit), AnyType(TypeOfAny.explicit)])
@@ -32,7 +32,7 @@ def return_proper_field_type_from_get_field(ctx: MethodContext, django_context:
     if model_cls is None:
         return ctx.default_return_type
 
-    field_name_expr = helpers.get_call_argument_by_name(ctx, 'field_name')
+    field_name_expr = chk_helpers.get_call_argument_by_name(ctx, 'field_name')
     if field_name_expr is None:
         return ctx.default_return_type
 

mypy_django_plugin/transformers/models.py

@@ -1,21 +1,21 @@
-from typing import Dict, List, Optional, Type, cast
+from typing import List, Optional, Type, cast
 
 from django.db.models.base import Model
-from django.db.models.fields import DateField, DateTimeField
-from django.db.models.fields.related import ForeignKey
+from django.db.models.fields.related import ForeignKey, OneToOneField
 from django.db.models.fields.reverse_related import (
     ManyToManyRel, ManyToOneRel, OneToOneRel,
 )
-from mypy.nodes import ARG_STAR2, Argument, Context, FuncDef, TypeInfo, Var
+from mypy.nodes import ARG_STAR2, Argument, FuncDef, TypeInfo, Var, SymbolTableNode, MDEF, GDEF
 from mypy.plugin import ClassDefContext
 from mypy.plugins import common
-from mypy.semanal import SemanticAnalyzer
+from mypy.semanal import SemanticAnalyzer, dummy_context
 from mypy.types import AnyType, Instance
 from mypy.types import Type as MypyType
 from mypy.types import TypeOfAny
 
+from django.db.models.fields import DateField, DateTimeField
 from mypy_django_plugin.django.context import DjangoContext
-from mypy_django_plugin.lib import fullnames, helpers
+from mypy_django_plugin.lib import fullnames, helpers, sem_helpers
 from mypy_django_plugin.transformers import fields
 from mypy_django_plugin.transformers.fields import get_field_descriptor_types
 
@@ -35,7 +35,7 @@ class ModelClassInitializer:
     def lookup_typeinfo_or_incomplete_defn_error(self, fullname: str) -> TypeInfo:
         info = self.lookup_typeinfo(fullname)
         if info is None:
-            raise helpers.IncompleteDefnException(f'No {fullname!r} found')
+            raise sem_helpers.IncompleteDefnException(f'No {fullname!r} found')
         return info
 
     def lookup_class_typeinfo_or_incomplete_defn_error(self, klass: type) -> TypeInfo:
@@ -43,26 +43,74 @@ class ModelClassInitializer:
         field_info = self.lookup_typeinfo_or_incomplete_defn_error(fullname)
         return field_info
 
-    def create_new_var(self, name: str, typ: MypyType) -> Var:
-        # type=: type of the variable itself
-        var = Var(name=name, type=typ)
-        # var.info: type of the object variable is bound to
+    def model_class_has_attribute_defined(self, name: str, traverse_mro: bool = True) -> bool:
+        if not traverse_mro:
+            sym = self.model_classdef.info.names.get(name)
+        else:
+            sym = self.model_classdef.info.get(name)
+        return sym is not None
+
+    def resolve_manager_fullname(self, manager_fullname: str) -> str:
+        base_manager_info = self.lookup_typeinfo(fullnames.MANAGER_CLASS_FULLNAME)
+        if (base_manager_info is None
+                or 'from_queryset_managers' not in base_manager_info.metadata):
+            return manager_fullname
+
+        metadata = base_manager_info.metadata['from_queryset_managers']
+        return metadata.get(manager_fullname, manager_fullname)
+
+    def add_new_node_to_model_class(self, name: str, typ: MypyType,
+                                    force_replace_existing: bool = False) -> None:
+        if not force_replace_existing and name in self.model_classdef.info.names:
+            raise ValueError(f'Member {name!r} already defined at model {self.model_classdef.info.fullname!r}.')
+
+        var = Var(name, type=typ)
+        # TypeInfo of the object variable is bound to
         var.info = self.model_classdef.info
-        var._fullname = self.model_classdef.info.fullname + '.' + name
+        var._fullname = self.api.qualified_name(name)
         var.is_initialized_in_class = True
-        var.is_inferred = True
-        return var
 
-    def add_new_node_to_model_class(self, name: str, typ: MypyType) -> None:
-        helpers.add_new_sym_for_info(self.model_classdef.info,
-                                     name=name,
-                                     sym_type=typ)
+        sym = SymbolTableNode(MDEF, var, plugin_generated=True)
+        context = dummy_context()
+        if force_replace_existing:
+            context = None
+        self.api.add_symbol_table_node(name, sym, context=context)
 
-    def add_new_class_for_current_module(self, name: str, bases: List[Instance]) -> TypeInfo:
-        current_module = self.api.modules[self.model_classdef.info.module_name]
-        new_class_info = helpers.add_new_class_for_module(current_module,
-                                                          name=name, bases=bases)
-        return new_class_info
+    def add_new_class_for_current_module(self, name: str, bases: List[Instance],
+                                         force_replace_existing: bool = False) -> Optional[TypeInfo]:
+        current_module = self.api.cur_mod_node
+        if not force_replace_existing and name in current_module:
+            raise ValueError(f'Class {name!r} already defined for module {current_module.fullname!r}')
+
+        new_typeinfo = helpers.new_typeinfo(name,
+                                            bases=bases,
+                                            module_name=current_module.fullname)
+        # sym = SymbolTableNode(GDEF, new_typeinfo,
+        #                       plugin_generated=True)
+        # context = dummy_context()
+        # if force_replace_existing:
+        #     context = None
+
+        if name in current_module.names:
+            del current_module.names[name]
+        current_module.names[name] = SymbolTableNode(GDEF, new_typeinfo, plugin_generated=True)
+        # current_module.defs.append(new_typeinfo.defn)
+        # self.api.cur_mod_node.
+        # self.api.leave_class()
+        # added = self.api.add_symbol_table_node(name, sym, context=context)
+        # self.api.enter_class(self.model_classdef.info)
+        #
+        # self.api.cur_mod_node.defs.append(new_typeinfo.defn)
+
+        # if not added and force_replace_existing:
+        #     return None
+        return new_typeinfo
+
+        # current_module = self.api.modules[self.model_classdef.info.module_name]
+        # context =
+        # new_class_info = helpers.add_new_class_for_module(current_module,
+        #                                                   name=name, bases=bases)
+        # return new_class_info
 
     def run(self) -> None:
         model_cls = self.django_context.get_model_class_by_fullname(self.model_classdef.fullname)
@@ -88,58 +136,90 @@ class InjectAnyAsBaseForNestedMeta(ModelClassInitializer):
     """
 
     def run(self) -> None:
-        meta_node = helpers.get_nested_meta_node_for_current_class(self.model_classdef.info)
+        meta_node = sem_helpers.get_nested_meta_node_for_current_class(self.model_classdef.info)
         if meta_node is None:
             return None
         meta_node.fallback_to_any = True
 
 
 class AddDefaultPrimaryKey(ModelClassInitializer):
+    """
+    Adds default primary key to models which does not define their own.
+    ```
+        class User(models.Model):
+            name = models.TextField()
+    ```
+    """
+
     def run_with_model_cls(self, model_cls: Type[Model]) -> None:
         auto_field = model_cls._meta.auto_field
-        if auto_field and not self.model_classdef.info.has_readable_member(auto_field.attname):
-            # autogenerated field
-            auto_field_fullname = helpers.get_class_fullname(auto_field.__class__)
-            auto_field_info = self.lookup_typeinfo_or_incomplete_defn_error(auto_field_fullname)
+        if auto_field is None:
+            return
 
-            set_type, get_type = fields.get_field_descriptor_types(auto_field_info, is_nullable=False)
-            self.add_new_node_to_model_class(auto_field.attname, Instance(auto_field_info,
-                                                                          [set_type, get_type]))
+        primary_key_attrname = auto_field.attname
+        if self.model_class_has_attribute_defined(primary_key_attrname):
+            return
+
+        auto_field_class_fullname = helpers.get_class_fullname(auto_field.__class__)
+        auto_field_info = self.lookup_typeinfo_or_incomplete_defn_error(auto_field_class_fullname)
+
+        set_type, get_type = fields.get_field_descriptor_types(auto_field_info, is_nullable=False)
+        self.add_new_node_to_model_class(primary_key_attrname, Instance(auto_field_info,
+                                                                        [set_type, get_type]))
 
 
 class AddRelatedModelsId(ModelClassInitializer):
+    """
+    Adds `FIELDNAME_id` attributes to models.
+    ```
+        class User(models.Model):
+            pass
+        class Blog(models.Model):
+            user = models.ForeignKey(User)
+    ```
+
+     `user_id` will be added to `Blog`.
+    """
+
     def run_with_model_cls(self, model_cls: Type[Model]) -> None:
         for field in model_cls._meta.get_fields():
-            if isinstance(field, ForeignKey):
-                related_model_cls = self.django_context.get_field_related_model_cls(field)
-                if related_model_cls is None:
-                    error_context: Context = self.ctx.cls
-                    field_sym = self.ctx.cls.info.get(field.name)
-                    if field_sym is not None and field_sym.node is not None:
-                        error_context = field_sym.node
-                    self.api.fail(f'Cannot find model {field.related_model!r} '
-                                  f'referenced in field {field.name!r} ',
-                                  ctx=error_context)
-                    self.add_new_node_to_model_class(field.attname,
-                                                     AnyType(TypeOfAny.explicit))
+            if not isinstance(field, (OneToOneField, ForeignKey)):
+                continue
+            related_id_attr_name = field.attname
+            if self.model_class_has_attribute_defined(related_id_attr_name):
+                continue
+            # if self.get_model_class_attr(related_id_attr_name) is not None:
+            #     continue
+
+            related_model_cls = self.django_context.get_field_related_model_cls(field)
+            if related_model_cls is None:
+                error_context = self.ctx.cls
+                field_sym = self.ctx.cls.info.get(field.name)
+                if field_sym is not None and field_sym.node is not None:
+                    error_context = field_sym.node
+                self.api.fail(f'Cannot find model {field.related_model!r} '
+                              f'referenced in field {field.name!r} ',
+                              ctx=error_context)
+                self.add_new_node_to_model_class(related_id_attr_name,
+                                                 AnyType(TypeOfAny.explicit))
+                continue
+
+            if related_model_cls._meta.abstract:
+                continue
+
+            rel_primary_key_field = self.django_context.get_primary_key_field(related_model_cls)
+            try:
+                field_info = self.lookup_class_typeinfo_or_incomplete_defn_error(rel_primary_key_field.__class__)
+            except sem_helpers.IncompleteDefnException as exc:
+                if not self.api.final_iteration:
+                    raise exc
+                else:
                     continue
 
-                if related_model_cls._meta.abstract:
-                    continue
-
-                rel_primary_key_field = self.django_context.get_primary_key_field(related_model_cls)
-                try:
-                    field_info = self.lookup_class_typeinfo_or_incomplete_defn_error(rel_primary_key_field.__class__)
-                except helpers.IncompleteDefnException as exc:
-                    if not self.api.final_iteration:
-                        raise exc
-                    else:
-                        continue
-
-                is_nullable = self.django_context.get_field_nullability(field, None)
-                set_type, get_type = get_field_descriptor_types(field_info, is_nullable)
-                self.add_new_node_to_model_class(field.attname,
-                                                 Instance(field_info, [set_type, get_type]))
+            is_nullable = self.django_context.get_field_nullability(field, None)
+            set_type, get_type = get_field_descriptor_types(field_info, is_nullable)
+            self.add_new_node_to_model_class(related_id_attr_name,
+                                             Instance(field_info, [set_type, get_type]))
 
 
 class AddManagers(ModelClassInitializer):
@@ -152,25 +232,15 @@ class AddManagers(ModelClassInitializer):
     def is_any_parametrized_manager(self, typ: Instance) -> bool:
         return typ.type.fullname in fullnames.MANAGER_CLASSES and isinstance(typ.args[0], AnyType)
 
-    def get_generated_manager_mappings(self, base_manager_fullname: str) -> Dict[str, str]:
-        base_manager_info = self.lookup_typeinfo(base_manager_fullname)
-        if (base_manager_info is None
-                or 'from_queryset_managers' not in base_manager_info.metadata):
-            return {}
-        return base_manager_info.metadata['from_queryset_managers']
-
     def create_new_model_parametrized_manager(self, name: str, base_manager_info: TypeInfo) -> Instance:
         bases = []
         for original_base in base_manager_info.bases:
             if self.is_any_parametrized_manager(original_base):
-                if original_base.type is None:
-                    raise helpers.IncompleteDefnException()
-
                 original_base = helpers.reparametrize_instance(original_base,
                                                                [Instance(self.model_classdef.info, [])])
             bases.append(original_base)
 
-        new_manager_info = self.add_new_class_for_current_module(name, bases)
+        new_manager_info = self.add_new_class_for_current_module(name, bases, force_replace_existing=True)
         # copy fields to a new manager
         new_cls_def_context = ClassDefContext(cls=new_manager_info.defn,
                                               reason=self.ctx.reason,
@@ -178,12 +248,15 @@ class AddManagers(ModelClassInitializer):
         custom_manager_type = Instance(new_manager_info, [Instance(self.model_classdef.info, [])])
 
         for name, sym in base_manager_info.names.items():
+            if name in new_manager_info.names:
+                raise ValueError(f'Name {name!r} already exists on newly-created {new_manager_info.fullname!r} class.')
+
             # replace self type with new class, if copying method
             if isinstance(sym.node, FuncDef):
-                helpers.copy_method_to_another_class(new_cls_def_context,
-                                                     self_type=custom_manager_type,
-                                                     new_method_name=name,
-                                                     method_node=sym.node)
+                sem_helpers.copy_method_or_incomplete_defn_exception(new_cls_def_context,
+                                                                     self_type=custom_manager_type,
+                                                                     new_method_name=name,
+                                                                     method_node=sym.node)
                 continue
 
             new_sym = sym.copy()
@@ -192,32 +265,36 @@ class AddManagers(ModelClassInitializer):
                 new_var.info = new_manager_info
                 new_var._fullname = new_manager_info.fullname + '.' + name
                 new_sym.node = new_var
+
             new_manager_info.names[name] = new_sym
 
         return custom_manager_type
 
     def run_with_model_cls(self, model_cls: Type[Model]) -> None:
         for manager_name, manager in model_cls._meta.managers_map.items():
-            manager_class_name = manager.__class__.__name__
-            manager_fullname = helpers.get_class_fullname(manager.__class__)
-            try:
-                manager_info = self.lookup_typeinfo_or_incomplete_defn_error(manager_fullname)
-            except helpers.IncompleteDefnException as exc:
-                if not self.api.final_iteration:
-                    raise exc
-                else:
-                    base_manager_fullname = helpers.get_class_fullname(manager.__class__.__bases__[0])
-                    generated_managers = self.get_generated_manager_mappings(base_manager_fullname)
-                    if manager_fullname not in generated_managers:
-                        # not a generated manager, continue with the loop
-                        continue
-                    real_manager_fullname = generated_managers[manager_fullname]
-                    manager_info = self.lookup_typeinfo(real_manager_fullname)  # type: ignore
-                    if manager_info is None:
-                        continue
-                    manager_class_name = real_manager_fullname.rsplit('.', maxsplit=1)[1]
+            if self.model_class_has_attribute_defined(manager_name, traverse_mro=False):
+                sym = self.model_classdef.info.names.get(manager_name)
+                assert sym is not None
+
+                if (sym.type is not None
+                        and isinstance(sym.type, Instance)
+                        and sym.type.type.has_base(fullnames.BASE_MANAGER_CLASS_FULLNAME)
+                        and not self.has_any_parametrized_manager_as_base(sym.type.type)):
+                    # already defined and parametrized properly
+                    continue
+
+            if getattr(manager, '_built_with_as_manager', False):
+                # as_manager is not supported yet
+                if not self.model_class_has_attribute_defined(manager_name, traverse_mro=True):
+                    self.add_new_node_to_model_class(manager_name, AnyType(TypeOfAny.explicit))
+                continue
+
+            manager_fullname = self.resolve_manager_fullname(helpers.get_class_fullname(manager.__class__))
+            manager_info = self.lookup_typeinfo_or_incomplete_defn_error(manager_fullname)
+            manager_class_name = manager_fullname.rsplit('.', maxsplit=1)[1]
 
             if manager_name not in self.model_classdef.info.names:
+                # manager not yet defined, just add models.Manager[ModelName]
                 manager_type = Instance(manager_info, [Instance(self.model_classdef.info, [])])
                 self.add_new_node_to_model_class(manager_name, manager_type)
             else:
@@ -226,56 +303,67 @@ class AddManagers(ModelClassInitializer):
                     continue
 
                 custom_model_manager_name = manager.model.__name__ + '_' + manager_class_name
-                try:
-                    custom_manager_type = self.create_new_model_parametrized_manager(custom_model_manager_name,
-                                                                                     base_manager_info=manager_info)
-                except helpers.IncompleteDefnException:
-                    continue
+                custom_manager_type = self.create_new_model_parametrized_manager(custom_model_manager_name,
+                                                                                 base_manager_info=manager_info)
 
-                self.add_new_node_to_model_class(manager_name, custom_manager_type)
+                self.add_new_node_to_model_class(manager_name, custom_manager_type,
+                                                 force_replace_existing=True)
 
 
 class AddDefaultManagerAttribute(ModelClassInitializer):
     def run_with_model_cls(self, model_cls: Type[Model]) -> None:
-        # add _default_manager
-        if '_default_manager' not in self.model_classdef.info.names:
-            default_manager_fullname = helpers.get_class_fullname(model_cls._meta.default_manager.__class__)
-            default_manager_info = self.lookup_typeinfo_or_incomplete_defn_error(default_manager_fullname)
-            default_manager = Instance(default_manager_info, [Instance(self.model_classdef.info, [])])
-            self.add_new_node_to_model_class('_default_manager', default_manager)
+        if self.model_class_has_attribute_defined('_default_manager', traverse_mro=False):
+            return
+        if model_cls._meta.default_manager is None:
+            return
+        if getattr(model_cls._meta.default_manager, '_built_with_as_manager', False):
+            self.add_new_node_to_model_class('_default_manager',
+                                             AnyType(TypeOfAny.explicit))
+            return
+
+        default_manager_fullname = helpers.get_class_fullname(model_cls._meta.default_manager.__class__)
+        resolved_default_manager_fullname = self.resolve_manager_fullname(default_manager_fullname)
+
+        default_manager_info = self.lookup_typeinfo_or_incomplete_defn_error(resolved_default_manager_fullname)
+        default_manager = Instance(default_manager_info, [Instance(self.model_classdef.info, [])])
+        self.add_new_node_to_model_class('_default_manager', default_manager)
 
 
 class AddRelatedManagers(ModelClassInitializer):
     def run_with_model_cls(self, model_cls: Type[Model]) -> None:
         # add related managers
         for relation in self.django_context.get_model_relations(model_cls):
-            attname = relation.get_accessor_name()
-            if attname is None:
+            related_manager_attr_name = relation.get_accessor_name()
+            if related_manager_attr_name is None:
                 # no reverse accessor
                 continue
 
+            if self.model_class_has_attribute_defined(related_manager_attr_name, traverse_mro=False):
+                continue
+
             related_model_cls = self.django_context.get_field_related_model_cls(relation)
             if related_model_cls is None:
                 continue
 
             try:
                 related_model_info = self.lookup_class_typeinfo_or_incomplete_defn_error(related_model_cls)
-            except helpers.IncompleteDefnException as exc:
+            except sem_helpers.IncompleteDefnException as exc:
                 if not self.api.final_iteration:
                     raise exc
                 else:
                     continue
 
             if isinstance(relation, OneToOneRel):
-                self.add_new_node_to_model_class(attname, Instance(related_model_info, []))
+                self.add_new_node_to_model_class(related_manager_attr_name, Instance(related_model_info, []))
                 continue
 
             if isinstance(relation, (ManyToOneRel, ManyToManyRel)):
                 try:
-                    related_manager_info = self.lookup_typeinfo_or_incomplete_defn_error(fullnames.RELATED_MANAGER_CLASS)  # noqa: E501
+                    related_manager_info = self.lookup_typeinfo_or_incomplete_defn_error(
+                        fullnames.RELATED_MANAGER_CLASS)  # noqa: E501
                     if 'objects' not in related_model_info.names:
-                        raise helpers.IncompleteDefnException()
-                except helpers.IncompleteDefnException as exc:
+                        raise sem_helpers.IncompleteDefnException()
+                except sem_helpers.IncompleteDefnException as exc:
                     if not self.api.final_iteration:
                         raise exc
                     else:
@@ -288,14 +376,20 @@ class AddRelatedManagers(ModelClassInitializer):
                 if (default_manager_type is None
                         or not isinstance(default_manager_type, Instance)
                         or default_manager_type.type.fullname == fullnames.MANAGER_CLASS_FULLNAME):
-                    self.add_new_node_to_model_class(attname, parametrized_related_manager_type)
+                    self.add_new_node_to_model_class(related_manager_attr_name, parametrized_related_manager_type)
                     continue
 
                 name = related_model_cls.__name__ + '_' + 'RelatedManager'
                 bases = [parametrized_related_manager_type, default_manager_type]
-                new_related_manager_info = self.add_new_class_for_current_module(name, bases)
+                new_related_manager_info = self.add_new_class_for_current_module(name, bases,
+                                                                                 force_replace_existing=True)
+                if new_related_manager_info is None:
+                    # wasn't added for some reason, defer
+                    if not self.api.final_iteration:
+                        self.api.defer()
+                        continue
 
-                self.add_new_node_to_model_class(attname, Instance(new_related_manager_info, []))
+                self.add_new_node_to_model_class(related_manager_attr_name, Instance(new_related_manager_info, []))
 
 
 class AddExtraFieldMethods(ModelClassInitializer):
@@ -355,6 +449,8 @@ def process_model_class(ctx: ClassDefContext,
     for initializer_cls in initializers:
         try:
             initializer_cls(ctx, django_context).run()
-        except helpers.IncompleteDefnException:
+        except sem_helpers.IncompleteDefnException as exc:
             if not ctx.api.final_iteration:
                 ctx.api.defer()
+                continue
+            raise exc

mypy_django_plugin/transformers/orm_lookups.py

@@ -4,7 +4,7 @@ from mypy.types import Type as MypyType
 from mypy.types import TypeOfAny
 
 from mypy_django_plugin.django.context import DjangoContext
-from mypy_django_plugin.lib import fullnames, helpers
+from mypy_django_plugin.lib import fullnames, helpers, chk_helpers
 
 
 def typecheck_queryset_filter(ctx: MethodContext, django_context: DjangoContext) -> MypyType:
@@ -35,10 +35,10 @@ def typecheck_queryset_filter(ctx: MethodContext, django_context: DjangoContext)
                                                                   fullnames.QUERYSET_CLASS_FULLNAME))):
             return ctx.default_return_type
 
-        helpers.check_types_compatible(ctx,
-                                       expected_type=lookup_type,
-                                       actual_type=provided_type,
-                                       error_message=f'Incompatible type for lookup {lookup_kwarg!r}:')
+        chk_helpers.check_types_compatible(ctx,
+                                           expected_type=lookup_type,
+                                           actual_type=provided_type,
+                                           error_message=f'Incompatible type for lookup {lookup_kwarg!r}:')
 
     return ctx.default_return_type
 

mypy_django_plugin/transformers/querysets.py

@@ -14,7 +14,7 @@ from mypy.types import TypeOfAny
 from mypy_django_plugin.django.context import (
     DjangoContext, LookupsAreUnsupported,
 )
-from mypy_django_plugin.lib import fullnames, helpers
+from mypy_django_plugin.lib import fullnames, helpers, chk_helpers
 
 
 def _extract_model_type_from_queryset(queryset_type: Instance) -> Optional[Instance]:
@@ -30,7 +30,7 @@ def determine_proper_manager_type(ctx: FunctionContext) -> MypyType:
     default_return_type = ctx.default_return_type
     assert isinstance(default_return_type, Instance)
 
-    outer_model_info = helpers.get_typechecker_api(ctx).scope.active_class()
+    outer_model_info = chk_helpers.get_typechecker_api(ctx).scope.active_class()
     if (outer_model_info is None
             or not outer_model_info.has_base(fullnames.MODEL_CLASS_FULLNAME)):
         return default_return_type
@@ -55,7 +55,7 @@ def get_field_type_from_lookup(ctx: MethodContext, django_context: DjangoContext
             return AnyType(TypeOfAny.from_error)
         lookup_field = django_context.get_primary_key_field(related_model_cls)
 
-    field_get_type = django_context.get_field_get_type(helpers.get_typechecker_api(ctx),
+    field_get_type = django_context.get_field_get_type(chk_helpers.get_typechecker_api(ctx),
                                                        lookup_field, method=method)
     return field_get_type
 
@@ -66,7 +66,7 @@ def get_values_list_row_type(ctx: MethodContext, django_context: DjangoContext,
     if field_lookups is None:
         return AnyType(TypeOfAny.from_error)
 
-    typechecker_api = helpers.get_typechecker_api(ctx)
+    typechecker_api = chk_helpers.get_typechecker_api(ctx)
     if len(field_lookups) == 0:
         if flat:
             primary_key_field = django_context.get_primary_key_field(model_cls)
@@ -80,7 +80,7 @@ def get_values_list_row_type(ctx: MethodContext, django_context: DjangoContext,
                 column_type = django_context.get_field_get_type(typechecker_api, field,
                                                                 method='values_list')
                 column_types[field.attname] = column_type
-            return helpers.make_oneoff_named_tuple(typechecker_api, 'Row', column_types)
+            return chk_helpers.make_oneoff_named_tuple(typechecker_api, 'Row', column_types)
         else:
             # flat=False, named=False, all fields
             field_lookups = []
@@ -103,9 +103,9 @@ def get_values_list_row_type(ctx: MethodContext, django_context: DjangoContext,
         assert len(column_types) == 1
         row_type = next(iter(column_types.values()))
     elif named:
-        row_type = helpers.make_oneoff_named_tuple(typechecker_api, 'Row', column_types)
+        row_type = chk_helpers.make_oneoff_named_tuple(typechecker_api, 'Row', column_types)
     else:
-        row_type = helpers.make_tuple(typechecker_api, list(column_types.values()))
+        row_type = chk_helpers.make_tuple(typechecker_api, list(column_types.values()))
 
     return row_type
 
@@ -123,13 +123,13 @@ def extract_proper_type_queryset_values_list(ctx: MethodContext, django_context:
     if model_cls is None:
         return ctx.default_return_type
 
-    flat_expr = helpers.get_call_argument_by_name(ctx, 'flat')
+    flat_expr = chk_helpers.get_call_argument_by_name(ctx, 'flat')
     if flat_expr is not None and isinstance(flat_expr, NameExpr):
         flat = helpers.parse_bool(flat_expr)
     else:
         flat = False
 
-    named_expr = helpers.get_call_argument_by_name(ctx, 'named')
+    named_expr = chk_helpers.get_call_argument_by_name(ctx, 'named')
     if named_expr is not None and isinstance(named_expr, NameExpr):
         named = helpers.parse_bool(named_expr)
     else:
@@ -188,5 +188,5 @@ def extract_proper_type_queryset_values(ctx: MethodContext, django_context: Djan
 
         column_types[field_lookup] = field_lookup_type
 
-    row_type = helpers.make_typeddict(ctx.api, column_types, set(column_types.keys()))
+    row_type = chk_helpers.make_oneoff_typeddict(ctx.api, column_types, set(column_types.keys()))
     return helpers.reparametrize_instance(ctx.default_return_type, [model_type, row_type])

mypy_django_plugin/transformers/request.py

@@ -3,13 +3,13 @@ from mypy.types import Instance
 from mypy.types import Type as MypyType
 
 from mypy_django_plugin.django.context import DjangoContext
-from mypy_django_plugin.lib import helpers
+from mypy_django_plugin.lib import helpers, chk_helpers
 
 
 def set_auth_user_model_as_type_for_request_user(ctx: AttributeContext, django_context: DjangoContext) -> MypyType:
     auth_user_model = django_context.settings.AUTH_USER_MODEL
     model_cls = django_context.apps_registry.get_model(auth_user_model)
-    model_info = helpers.lookup_class_typeinfo(helpers.get_typechecker_api(ctx), model_cls)
+    model_info = helpers.lookup_class_typeinfo(chk_helpers.get_typechecker_api(ctx), model_cls)
     if model_info is None:
         return ctx.default_attr_type
 

mypy_django_plugin/transformers/settings.py

@@ -5,7 +5,7 @@ from mypy.types import Type as MypyType
 from mypy.types import TypeOfAny, TypeType
 
 from mypy_django_plugin.django.context import DjangoContext
-from mypy_django_plugin.lib import helpers
+from mypy_django_plugin.lib import helpers, chk_helpers
 
 
 def get_user_model_hook(ctx: FunctionContext, django_context: DjangoContext) -> MypyType:
@@ -13,7 +13,7 @@ def get_user_model_hook(ctx: FunctionContext, django_context: DjangoContext) ->
     model_cls = django_context.apps_registry.get_model(auth_user_model)
     model_cls_fullname = helpers.get_class_fullname(model_cls)
 
-    model_info = helpers.lookup_fully_qualified_typeinfo(helpers.get_typechecker_api(ctx),
+    model_info = helpers.lookup_fully_qualified_typeinfo(chk_helpers.get_typechecker_api(ctx),
                                                          model_cls_fullname)
     if model_info is None:
         return AnyType(TypeOfAny.unannotated)
@@ -28,7 +28,7 @@ def get_type_of_settings_attribute(ctx: AttributeContext, django_context: Django
         ctx.api.fail(f"'Settings' object has no attribute {setting_name!r}", ctx.context)
         return ctx.default_attr_type
 
-    typechecker_api = helpers.get_typechecker_api(ctx)
+    typechecker_api = chk_helpers.get_typechecker_api(ctx)
 
     # first look for the setting in the project settings file, then global settings
     settings_module = typechecker_api.modules.get(django_context.django_settings_module)