Jul 12, 2023 · Jun 4, 2023 · Jun 4, 2023 · Jun 4, 2023 · Jun 4, 2023 · Jul 12, 2023
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
        if isinstance(caller_type, DeletedType):
            self.msg.deleted_as_rvalue(caller_type, context)
        # Only non-abstract non-protocol class can be given where Type[...] is expected...
        elif (
            isinstance(caller_type, CallableType)
            and isinstance(callee_type, TypeType)
            and caller_type.is_type_obj()
            and (caller_type.type_object().is_abstract or caller_type.type_object().is_protocol)
            and isinstance(callee_type.item, Instance)
            and (callee_type.item.type.is_abstract or callee_type.item.type.is_protocol)
            and not self.chk.allow_abstract_call
        ):
        elif self.has_abstract_type_part(caller_type, callee_type):
            self.msg.concrete_only_call(callee_type, context)
        elif not is_subtype(caller_type, callee_type, options=self.chk.options):
            code = self.msg.incompatible_argument(
                return narrow_declared_type(known_type, restriction)
        return known_type

    def has_abstract_type_part(
        self, caller_type: ProperType, callee_type: ProperType
    ) -> ProperType | None:
        if isinstance(caller_type, TupleType) and isinstance(callee_type, TupleType):
            return any(
                self.has_abstract_type_part(caller, callee)
                for caller, callee in zip(caller_type.items, callee_type.items)
            )
        return (
            isinstance(caller_type, CallableType)
            and isinstance(callee_type, TypeType)
            and caller_type.is_type_obj()
            and (caller_type.type_object().is_abstract or caller_type.type_object().is_protocol)
            and isinstance(callee_type.item, Instance)
            and (callee_type.item.type.is_abstract or callee_type.item.type.is_protocol)
            and not self.chk.allow_abstract_call
        )


 def has_any_type(t: Type, ignore_in_type_obj: bool = False) -> bool:
    """Whether t contains an Any type"""
diff --git a/test-data/unit/check-abstract.test b/test-data/unit/check-abstract.test
 f(x)  # OK
 [out]

 [case testAbstractTypeInADict]
 from typing import Dict, Type
 from abc import abstractmethod

 class Class:
    @abstractmethod
    def method(self) -> None:
        pass

 my_dict_init: Dict[int, Type[Class]] = {0: Class}  # E: Only concrete class can be given where "Tuple[int, Type[Class]]" is expected

 class Child(Class):
    def method(self) -> None: ...

 other_dict_init: Dict[int, Type[Class]] = {0: Child}  # ok
 [builtins fixtures/dict.pyi]
 [out]

 [case testInstantiationAbstractsInTypeForAliases]
 from typing import Type
 from abc import abstractmethod
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2166,15 +2166,7 @@ def check_arg(
		if isinstance(caller_type, DeletedType):
		self.msg.deleted_as_rvalue(caller_type, context)
		# Only non-abstract non-protocol class can be given where Type[...] is expected...
		elif (
		isinstance(caller_type, CallableType)
		and isinstance(callee_type, TypeType)
		and caller_type.is_type_obj()
		and (caller_type.type_object().is_abstract or caller_type.type_object().is_protocol)
		and isinstance(callee_type.item, Instance)
		and (callee_type.item.type.is_abstract or callee_type.item.type.is_protocol)
		and not self.chk.allow_abstract_call
		):
		elif self.has_abstract_type_part(caller_type, callee_type):
		self.msg.concrete_only_call(callee_type, context)
		elif not is_subtype(caller_type, callee_type, options=self.chk.options):
		code = self.msg.incompatible_argument(
Expand DownExpand Up		@@ -5287,6 +5279,24 @@ def narrow_type_from_binder(
		return narrow_declared_type(known_type, restriction)
		return known_type

		def has_abstract_type_part(
		self, caller_type: ProperType, callee_type: ProperType
		) -> ProperType \| None:
		if isinstance(caller_type, TupleType) and isinstance(callee_type, TupleType):
		return any(
		self.has_abstract_type_part(caller, callee)
		for caller, callee in zip(caller_type.items, callee_type.items)
		)
		return (
		isinstance(caller_type, CallableType)
		and isinstance(callee_type, TypeType)
		and caller_type.is_type_obj()
		and (caller_type.type_object().is_abstract or caller_type.type_object().is_protocol)
		and isinstance(callee_type.item, Instance)
		and (callee_type.item.type.is_abstract or callee_type.item.type.is_protocol)
		and not self.chk.allow_abstract_call
		)


		def has_any_type(t: Type, ignore_in_type_obj: bool = False) -> bool:
		"""Whether t contains an Any type"""
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -196,6 +196,24 @@ x: Type[B]
		f(x) # OK
		[out]

		[case testAbstractTypeInADict]
		from typing import Dict, Type
		from abc import abstractmethod

		class Class:
		@abstractmethod
		def method(self) -> None:
		pass

		my_dict_init: Dict[int, Type[Class]] = {0: Class} # E: Only concrete class can be given where "Tuple[int, Type[Class]]" is expected

		class Child(Class):
		def method(self) -> None: ...

		other_dict_init: Dict[int, Type[Class]] = {0: Child} # ok
		[builtins fixtures/dict.pyi]
		[out]

		[case testInstantiationAbstractsInTypeForAliases]
		from typing import Type
		from abc import abstractmethod
Expand Down