Add new check: unguarded-typing-import

pylint/checkers/variables.py

@@ -24,6 +24,7 @@
 from pylint.checkers.utils import (
  in_type_checking_block,
  is_module_ignored,
+ is_node_in_type_annotation_context,
  is_postponed_evaluation_enabled,
  is_sys_guard,
  overridden_method,
@@ -409,6 +410,14 @@ def _has_locals_call_after_node(stmt: nodes.NodeNG, scope: nodes.FunctionDef) ->
  "Used when an imported module or variable is not used from a "
  "`'from X import *'` style import.",
  ),
+ "R0615": (
+ "`%s` used only for typechecking but imported outside of a typechecking block",
+ "unguarded-typing-import",
+ "Used when an import is used only for typechecking but imported outside of a typechecking block.",
+ {
+ "default_enabled": False,
+ },
+ ),
  "W0621": (
  "Redefining name %r from outer scope (line %s)",
  "redefined-outer-name",
@@ -482,6 +491,7 @@ class NamesConsumer:
 
  to_consume: Consumption
  consumed: Consumption
+ consumed_as_type: Consumption
  consumed_uncertain: Consumption
  """Retrieves nodes filtered out by get_next_to_consume() that may not
  have executed.
@@ -498,6 +508,7 @@ def __init__(self, node: nodes.NodeNG, scope_type: str):
 
  self.to_consume = copy.copy(node.locals)
  self.consumed = {}
+ self.consumed_as_type = {}
  self.consumed_uncertain = defaultdict(list)
 
  self.names_under_always_false_test: set[str] = set()
@@ -506,30 +517,46 @@ def __init__(self, node: nodes.NodeNG, scope_type: str):
  def __repr__(self) -> str:
  _to_consumes = [f"{k}->{v}" for k, v in self.to_consume.items()]
  _consumed = [f"{k}->{v}" for k, v in self.consumed.items()]
+ _consumed_as_type = [f"{k}->{v}" for k, v in self.consumed_as_type.items()]
  _consumed_uncertain = [f"{k}->{v}" for k, v in self.consumed_uncertain.items()]
  to_consumes = ", ".join(_to_consumes)
  consumed = ", ".join(_consumed)
+ consumed_as_type = ", ".join(_consumed_as_type)
  consumed_uncertain = ", ".join(_consumed_uncertain)
  return f"""
 to_consume : {to_consumes}
 consumed : {consumed}
+consumed_as_type : {consumed_as_type}
 consumed_uncertain: {consumed_uncertain}
 scope_type : {self.scope_type}
 """
 
- def mark_as_consumed(self, name: str, consumed_nodes: list[nodes.NodeNG]) -> None:
+ def mark_as_consumed(
+ self,
+ name: str,
+ consumed_nodes: list[nodes.NodeNG],
+ consumed_as_type: bool = False,
+ ) -> None:
  """Mark the given nodes as consumed for the name.
 
  If all of the nodes for the name were consumed, delete the name from
  the to_consume dictionary
  """
- unconsumed = [n for n in self.to_consume[name] if n not in set(consumed_nodes)]
- self.consumed[name] = consumed_nodes
+ consumed = self.consumed_as_type if consumed_as_type else self.consumed
+ consumed[name] = consumed_nodes
 
- if unconsumed:
- self.to_consume[name] = unconsumed
- else:
- del self.to_consume[name]
+ if name in self.to_consume:
+ unconsumed = [
+ n for n in self.to_consume[name] if n not in set(consumed_nodes)
+ ]
+
+ if unconsumed:
+ self.to_consume[name] = unconsumed
+ else:
+ del self.to_consume[name]
+
+ if not consumed_as_type and name in self.consumed_as_type:
+ del self.consumed_as_type[name]
 
  def get_next_to_consume(self, node: nodes.Name) -> list[nodes.NodeNG] | None:
  """Return a list of the nodes that define `node` from this scope.
@@ -572,6 +599,9 @@ def get_next_to_consume(self, node: nodes.Name) -> list[nodes.NodeNG] | None:
  if VariablesChecker._comprehension_between_frame_and_node(node):
  return found_nodes
 
+ if found_nodes is None:
+ found_nodes = self.consumed_as_type.get(name)
+
  # Filter out assignments in ExceptHandlers that node is not contained in
  if found_nodes:
  found_nodes = [
@@ -1356,7 +1386,8 @@ def leave_module(self, node: nodes.Module) -> None:
  assert len(self._to_consume) == 1
 
  self._check_metaclasses(node)
- not_consumed = self._to_consume.pop().to_consume
+ consumer = self._to_consume.pop()
+ not_consumed = consumer.to_consume
  # attempt to check for __all__ if defined
  if "__all__" in node.locals:
  self._check_all(node, not_consumed)
@@ -1368,7 +1399,7 @@ def leave_module(self, node: nodes.Module) -> None:
  if not self.linter.config.init_import and node.package:
  return
 
- self._check_imports(not_consumed)
+ self._check_imports(not_consumed, consumer.consumed_as_type)
  self._type_annotation_names = []
 
  def visit_classdef(self, node: nodes.ClassDef) -> None:
@@ -1672,7 +1703,11 @@ def _undefined_and_used_before_checker(
  # They will have already had a chance to emit used-before-assignment.
  # We check here instead of before every single return in _check_consumer()
  nodes_to_consume += current_consumer.consumed_uncertain[node.name]
- current_consumer.mark_as_consumed(node.name, nodes_to_consume)
+ current_consumer.mark_as_consumed(
+ node.name,
+ nodes_to_consume,
+ consumed_as_type=is_node_in_type_annotation_context(node),
+ )
  if action is VariableVisitConsumerAction.CONTINUE:
  continue
  if action is VariableVisitConsumerAction.RETURN:
@@ -3163,7 +3198,11 @@ def _check_globals(self, not_consumed: Consumption) -> None:
  self.add_message("unused-variable", args=(name,), node=node)
 
  # pylint: disable = too-many-branches
- def _check_imports(self, not_consumed: Consumption) -> None:
+ def _check_imports(
+ self,
+ not_consumed: Consumption,
+ consumed_as_type: Consumption,
+ ) -> None:
  local_names = _fix_dot_imports(not_consumed)
  checked = set()
  unused_wildcard_imports: defaultdict[
@@ -3251,8 +3290,26 @@ def _check_imports(self, not_consumed: Consumption) -> None:
  self.add_message(
  "unused-wildcard-import", args=(arg_string, module[0]), node=module[1]
  )
+
+ self._check_type_imports(consumed_as_type)
+
  del self._to_consume
 
+ def _check_type_imports(
+ self,
+ consumed_as_type: dict[str, list[nodes.NodeNG]],
+ ) -> None:
+ for name, import_node in _fix_dot_imports(consumed_as_type):
+ if import_node.names[0][0] == "*":
+ continue
+
+ if not in_type_checking_block(import_node):
+ self.add_message(
+ "unguarded-typing-import",
+ args=name,
+ node=import_node,
+ )
+
  def _check_metaclasses(self, node: nodes.Module | nodes.FunctionDef) -> None:
  """Update consumption analysis for metaclasses."""
  consumed: list[tuple[Consumption, str]] = []

tests/functional/u/unguarded_typing_import.py

@@ -0,0 +1,21 @@
+# pylint: disable = import-error, missing-module-docstring, missing-function-docstring, missing-class-docstring, too-few-public-methods,
+
+from mod import A # [unguarded-typing-import]
+from mod import B
+
+def f(_: A):
+ pass
+
+def g(x: B):
+ assert isinstance(x, B)
+
+class C:
+ pass
+
+class D:
+ c: C
+
+ def h(self):
+ # --> BUG <--
+ # pylint: disable = undefined-variable
+ return [C() for _ in self.c]

tests/functional/u/unguarded_typing_import.rc

@@ -0,0 +1,2 @@
+[MESSAGES CONTROL]
+enable = unguarded-typing-import

tests/functional/u/unguarded_typing_import.txt

@@ -0,0 +1 @@
+unguarded-typing-import:3:0:3:17::`A` used only for typechecking but imported outside of a typechecking block:UNDEFINED