Check for contextlib.suppress in node_ignores_exception (#7327)

Author: DanielNoord

doc/whatsnew/fragments/7270.false_positive

@@ -0,0 +1,3 @@
+``import-error`` now correctly checks for ``contextlib.suppress`` guards on import statements.
+
+Closes #7270

pylint/checkers/utils.py

@@ -1045,7 +1045,7 @@ def _except_handlers_ignores_exceptions(
 
 
 def get_exception_handlers(
-    node: nodes.NodeNG, exception: type[Exception] = Exception
+    node: nodes.NodeNG, exception: type[Exception] | str = Exception
 ) -> list[nodes.ExceptHandler] | None:
     """Return the collections of handlers handling the exception in arguments.
 
@@ -1064,6 +1064,59 @@ def get_exception_handlers(
     return []
 
 
+def get_contextlib_with_statements(node: nodes.NodeNG) -> Iterator[nodes.With]:
+    """Get all contextlib.with statements in the ancestors of the given node."""
+    for with_node in node.node_ancestors():
+        if isinstance(with_node, nodes.With):
+            yield with_node
+
+
+def _suppresses_exception(
+    call: nodes.Call, exception: type[Exception] | str = Exception
+) -> bool:
+    """Check if the given node suppresses the given exception."""
+    if not isinstance(exception, str):
+        exception = exception.__name__
+    for arg in call.args:
+        inferred = safe_infer(arg)
+        if isinstance(inferred, nodes.ClassDef):
+            if inferred.name == exception:
+                return True
+        elif isinstance(inferred, nodes.Tuple):
+            for elt in inferred.elts:
+                inferred_elt = safe_infer(elt)
+                if (
+                    isinstance(inferred_elt, nodes.ClassDef)
+                    and inferred_elt.name == exception
+                ):
+                    return True
+    return False
+
+
+def get_contextlib_suppressors(
+    node: nodes.NodeNG, exception: type[Exception] | str = Exception
+) -> Iterator[nodes.With]:
+    """Return the contextlib suppressors handling the exception.
+
+    Args:
+        node (nodes.NodeNG): A node that is potentially wrapped in a contextlib.suppress.
+        exception (builtin.Exception): exception or name of the exception.
+
+    Yields:
+        nodes.With: A with node that is suppressing the exception.
+    """
+    for with_node in get_contextlib_with_statements(node):
+        for item, _ in with_node.items:
+            if isinstance(item, nodes.Call):
+                inferred = safe_infer(item.func)
+                if (
+                    isinstance(inferred, nodes.ClassDef)
+                    and inferred.qname() == "contextlib.suppress"
+                ):
+                    if _suppresses_exception(item, exception):
+                        yield with_node
+
+
 def is_node_inside_try_except(node: nodes.Raise) -> bool:
     """Check if the node is directly under a Try/Except statement
     (but not under an ExceptHandler!).
@@ -1079,17 +1132,17 @@ def is_node_inside_try_except(node: nodes.Raise) -> bool:
 
 
 def node_ignores_exception(
-    node: nodes.NodeNG, exception: type[Exception] = Exception
+    node: nodes.NodeNG, exception: type[Exception] | str = Exception
 ) -> bool:
     """Check if the node is in a TryExcept which handles the given exception.
 
     If the exception is not given, the function is going to look for bare
     excepts.
     """
     managing_handlers = get_exception_handlers(node, exception)
-    if not managing_handlers:
-        return False
-    return any(managing_handlers)
+    if managing_handlers:
+        return True
+    return any(get_contextlib_suppressors(node, exception))
 
 
 def class_is_abstract(node: nodes.ClassDef) -> bool:

tests/functional/i/import_error.py

@@ -79,3 +79,32 @@
 
 import foo
 import bar
+
+# Issues with contextlib.suppress reported in
+# https://github.com/PyCQA/pylint/issues/7270
+import contextlib
+with contextlib.suppress(ImportError):
+    import foo2
+
+with contextlib.suppress(ValueError):
+    import foo2  # [import-error]
+
+with contextlib.suppress(ImportError, ValueError):
+    import foo2
+
+with contextlib.suppress((ImportError, ValueError)):
+    import foo2
+
+with contextlib.suppress((ImportError,), (ValueError,)):
+    import foo2
+
+x = True
+with contextlib.suppress(ImportError):
+    if x:
+        import foo2
+    else:
+        pass
+
+with contextlib.suppress(ImportError):
+    with contextlib.suppress(TypeError):
+        import foo2

tests/functional/i/import_error.txt

@@ -3,3 +3,4 @@ import-error:21:4:21:26::Unable to import 'maybe_missing_2':UNDEFINED
 no-name-in-module:33:0:33:49::No name 'syntax_error' in module 'functional.s.syntax':UNDEFINED
 syntax-error:33:0:None:None::Cannot import 'functional.s.syntax.syntax_error' due to 'invalid syntax (<unknown>, line 1)':HIGH
 multiple-imports:78:0:78:15::Multiple imports on one line (foo, bar):UNDEFINED
+import-error:90:4:90:15::Unable to import 'foo2':UNDEFINED