Fixed Optional without subscript being used for type checks

Fixes #342.

docs/versionhistory.rst

@@ -3,6 +3,11 @@ Version history
 
 This library adheres to `Semantic Versioning 2.0 <https://semver.org/#semantic-versioning-200>`_.
 
+**UNRELEASED**
+
+- Fixed instrumentation using ``typing.Optional`` without a subscript when the subscript
+  value was erased due to being an ignored import
+
 **4.0.0rc4** (2023-04-15)
 
 - Fixed imports guarded by ``if TYPE_CHECKING:`` when used with subscripts

src/typeguard/_transformer.py

@@ -410,8 +410,11 @@ def visit_Subscript(self, node: Subscript) -> Any:
                 self.generic_visit(node)
 
                 # If the transformer erased the slice entirely, just return the node
-                # value without the subscript
-                if sys.version_info >= (3, 9) and not hasattr(node, "slice"):
+                # value without the subscript (unless it's Optional, in which case erase
+                # the node entirely
+                if self._memo.name_matches(node.value, "typing.Optional"):
+                    return None
+                elif sys.version_info >= (3, 9) and not hasattr(node, "slice"):
                     return node.value
                 elif sys.version_info < (3, 9) and not hasattr(node.slice, "value"):
                     return node.value

tests/test_transformer.py

@@ -921,6 +921,36 @@ def foo(x: Hashable, y: typing.Collection) -> Generator[Hashable, \
             ).strip()
         )
 
+    def test_optional(self) -> None:
+        node = parse(
+            dedent(
+                """
+                from typing import Any, Optional, TYPE_CHECKING
+                from collections.abc import Generator
+                if TYPE_CHECKING:
+                    from typing import Hashable
+
+                def foo(x: Optional[Hashable]) -> Optional[Hashable]:
+                    return x
+                """
+            )
+        )
+        TypeguardTransformer().visit(node)
+        assert (
+            unparse(node)
+            == dedent(
+                """
+                from typing import Any, Optional, TYPE_CHECKING
+                from collections.abc import Generator
+                if TYPE_CHECKING:
+                    from typing import Hashable
+
+                def foo(x: Optional[Hashable]) -> Optional[Hashable]:
+                    return x
+                """
+            ).strip()
+        )
+
 
 class TestAssign:
     def test_annotated_assign(self) -> None: