build(lint): enable 8 more mypy error codes + fix violations

Add eight error codes to [tool.mypy] enable_error_code on top of
explicit-override: ignore-without-code, truthy-iterable, redundant-self,
unused-awaitable (free — zero violations), truthy-bool, redundant-expr,
possibly-undefined, mutable-override (cheap — fixed below). Deliberately
NOT warn_unreachable / disallow_any_decorated: they false-positive against
the ProtoEnum dynamic-_missing_ `case _:` pattern and stdlib decorator
machinery (Any-typed), respectively.

Categories fixed:

- truthy-bool + packet-handler redundant-expr (cast-away-None root cause):
  the UDP/TCP/ICMPv4/ICMPv6 RX handlers cast stack.sockets.get(...) /
  get_for_ingress(...) — both `socket | None` — to a bare TcpSocket /
  UdpSocket, lying to mypy that the lookup never returns None. That single
  dishonesty produced the truthy-bool walrus warnings and the
  `is None or` / `is not None and` redundant-expr warnings. Made every
  cast honest (`cast(UdpSocket | None, ...)` / `cast(TcpSocket | None,
  ...)`) and converted walrus-truthiness to explicit `is None` / `is not
  None` checks. Runtime is identical — the handlers already coped with
  None via truthiness; only the type is now honest and the guard explicit.

- possibly-undefined: enum __str__ `match self` blocks bound `name` only
  on the known-member cases, leaving it unbound for a dynamically
  materialised unknown ProtoEnum member. Added a `case _:` default that
  binds the existing fallback form and dropped the now-redundant
  `... if self.is_unknown else name` ternary, keeping identical output for
  known and unknown members (net_proto lib/enums + dhcp4/dhcp6/dns/llc/
  ip6_routing enums).

- redundant-expr (defensive isinstance guards): for net_addr Ip4/Ip6Network
  tuple-form validation and the DHCPv4 classless-static-route __post_init__,
  mypy proves the element-type isinstance operands statically true from the
  declared types, but the runtime checks are load-bearing (a test pins the
  DHCPv4 wrong-element rejection; the network guard prevents a bare-builtin
  int(str) later). Kept the guards: extracted a `_is_well_formed_route`
  helper typed `object` for DHCPv4 (no suppression needed), and a narrow
  justified `# type: ignore[redundant-expr]` for the two network files.
  The sendmsg ancdata 3-tuple check was genuinely redundant (item is
  already a tuple) — simplified to `len(item) != 3`.

- mutable-override: TCP cubic/cwnd integration test classes set
  `_DEFAULT_CC_MODE = CcMode.RENO`, narrowing the TcpTestCase base attr
  typed `CcMode | None`. Annotated each override `: CcMode | None` to keep
  the base type.

- examples_legacy / tests_runner (same gate): dropped a dead `if subsystem`
  truthy filter in stack.py, added a `case _: assert_never(ip_version)`
  exhaustiveness guard in client__icmp_echo.py, and annotated
  TestslideStyleRunner.resultclass to the base's mutable
  `Callable[..., TextTestResult]` type.

- Real latent bug: stack/__init__.py boot defaults IP4_ADDRESS / IP6_ADDRESS
  / IP4_GATEWAY / IP6_GATEWAY were unannotated `= None`, so mypy inferred
  type `None`, making the operator-set boot-address path in lifecycle.init
  (`Ip4IfAddr(_stack.IP4_ADDRESS)` etc.) dead to the type checker. Annotated
  to the real intended types (`str | None` for the host addresses consumed by
  Ip{4,6}IfAddr(...), `Ip{4,6}Address | None` for the gateways passed to
  install_boot_default_routes). No cascade.

Doc: typing.md §2.1 documents the now-enabled extra codes and why
warn_unreachable / disallow_any_decorated stay off; §21 notes
ignore-without-code now mechanically forbids bare `# type: ignore`.

make lint clean, 12752 passing / 0 failing / 0 skipped, no leaked log lines.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ccie18643

.claude/rules/typing.md

@@ -57,6 +57,29 @@ You don't need to remember the flag names — `make lint` is
 the authoritative gate. The list above explains *why* a
 particular rule from this file is enforced.
 
+### 2.1 Extra `enable_error_code` codes
+
+On top of the strict bundle, `pyproject.toml` opts into
+nine extra error codes via `enable_error_code` — each one
+upgrades a latent footgun from silent-pass to build-break:
+
+| Error code | Effect |
+|---|---|
+| `explicit-override` | A method overriding a parent MUST carry `@override` (§11) — enforced everywhere, tests included |
+| `ignore-without-code` | A bare `# type: ignore` is a hard error; the narrow `# type: ignore[code]` form is mandatory (§21) |
+| `truthy-bool` | An object with no `__bool__` / `__len__` used in a boolean context (e.g. `if socket :=` where the type can't be falsy) is flagged |
+| `truthy-iterable` | An always-truthy iterable used as a plain boolean condition is flagged |
+| `redundant-expr` | An `and` / `or` operand that mypy proves constant (always-true / always-false) is flagged |
+| `redundant-self` | A redundant `Self`-typed `self` annotation is flagged |
+| `possibly-undefined` | A name that may be unbound on some control-flow path (e.g. a `match` with no `case _:` default leaving a variable unset) is flagged |
+| `unused-awaitable` | An awaitable whose result is discarded without `await` is flagged |
+| `mutable-override` | A subclass narrowing a mutable base attribute's type (covariant override of a settable field) is flagged — applies to test classes too |
+
+`warn_unreachable` and `disallow_any_decorated` are
+deliberately **not** enabled: they produce false positives
+against the `ProtoEnum` dynamic-`_missing_` `case _:` pattern
+and stdlib decorator machinery.
+
 ## 3. Annotation discipline — what MUST be annotated
 
 | Construct | Annotation requirement |
@@ -1028,7 +1051,10 @@ Acceptable uses:
   ```
   The narrow form `# type: ignore[error-code]` is mandatory
   — bare `# type: ignore` is forbidden because it suppresses
-  every error on the line, not just the intended one.
+  every error on the line, not just the intended one. This is
+  now **mechanically enforced**: the `ignore-without-code`
+  error code (§2.1) makes a bare `# type: ignore` a hard
+  build error, not just a convention.
 
 - **Mypy strict false-positive that has a known issue
   upstream.** Cite the issue:

examples_legacy/client__icmp_echo.py

@@ -38,7 +38,7 @@
 import os
 import struct
 import threading
-from typing import Any, override
+from typing import Any, assert_never, override
 
 import click
 from examples_legacy.lib.client import Client
@@ -121,6 +121,8 @@ def _assemble_icmp_echo_request_message(
             case IpVersion.IP4:
                 icmp_type = ICMP4__ECHO_REQUEST__TYPE
                 icmp_code = ICMP4__ECHO_REQUEST__CODE
+            case _:
+                assert_never(ip_version)
 
         data = payload(length=message_size)
 

examples_legacy/stack.py

@@ -382,7 +382,7 @@ def _on_sigusr1(_signum: int, _frame: FrameType | None) -> None:
         _last_stats = time.monotonic()
         _last_snapshot = _capture_stats_snapshot()
 
-        while any(subsystem.is_alive for subsystem in subsystems if subsystem) or not subsystems:
+        while any(subsystem.is_alive for subsystem in subsystems) or not subsystems:
             time.sleep(1)
             if _remove_requested[0]:
                 _remove_requested[0] = False

packages/net_addr/net_addr/ip4_network.py

@@ -92,7 +92,15 @@ def __init__(
             if len(network) != 2:
                 raise Ip4NetworkFormatError(network)
             tuple_address, tuple_mask = network
-            if not (isinstance(tuple_address, Ip4Address) and isinstance(tuple_mask, Ip4Mask)):
+            # Defensive runtime guard: the parameter is typed
+            # 'tuple[Ip4Address, Ip4Mask]', so mypy proves the first
+            # 'isinstance' operand statically true, but the check is
+            # load-bearing — a mistyped tuple must raise the net_addr
+            # error here rather than blowing up later on 'int(...)'.
+            if not (
+                isinstance(tuple_address, Ip4Address)  # type: ignore[redundant-expr]
+                and isinstance(tuple_mask, Ip4Mask)
+            ):
                 raise Ip4NetworkFormatError(network)
             if strict and int(tuple_address) & ~int(tuple_mask) & IP4__MASK:
                 raise Ip4NetworkFormatError(network)

packages/net_addr/net_addr/ip6_network.py

@@ -92,7 +92,15 @@ def __init__(
             if len(network) != 2:
                 raise Ip6NetworkFormatError(network)
             tuple_address, tuple_mask = network
-            if not (isinstance(tuple_address, Ip6Address) and isinstance(tuple_mask, Ip6Mask)):
+            # Defensive runtime guard: the parameter is typed
+            # 'tuple[Ip6Address, Ip6Mask]', so mypy proves the first
+            # 'isinstance' operand statically true, but the check is
+            # load-bearing — a mistyped tuple must raise the net_addr
+            # error here rather than blowing up later on 'int(...)'.
+            if not (
+                isinstance(tuple_address, Ip6Address)  # type: ignore[redundant-expr]
+                and isinstance(tuple_mask, Ip6Mask)
+            ):
                 raise Ip6NetworkFormatError(network)
             # A prefix has no RFC 4007 zone; reject a scoped
             # address rather than silently dropping the zone.

packages/net_proto/net_proto/lib/enums.py

@@ -61,8 +61,10 @@ def __str__(self) -> str:
                 name = "IPv6"
             case EtherType.RAW:
                 name = "Raw"
+            case _:
+                name = f"0x{self.value:0>4x}"
 
-        return f"0x{self.value:0>4x}" if self.is_unknown else name
+        return name
 
     @staticmethod
     def from_proto(proto: Proto) -> EtherType:
@@ -142,8 +144,10 @@ def __str__(self) -> str:
                 name = "IPv6_DestOpts"
             case IpProto.RAW:
                 name = "Raw"
+            case _:
+                name = f"{self.value}"
 
-        return f"{self.value}" if self.is_unknown else name
+        return name
 
     @staticmethod
     def from_proto(proto: Proto) -> IpProto:

packages/net_proto/net_proto/protocols/dhcp4/dhcp4__enums.py

@@ -92,5 +92,7 @@ def __str__(self) -> str:
                 name = "Release"
             case Dhcp4MessageType.INFORM:
                 name = "Inform"
+            case _:
+                name = f"{self.value}"
 
-        return f"{self.value}" if self.is_unknown else name
+        return name

packages/net_proto/net_proto/protocols/dhcp4/options/dhcp4__option__classless_static_route.py

@@ -75,6 +75,25 @@ def _significant_octet_count(prefixlen: int, /) -> int:
     return (prefixlen + 7) // 8
 
 
+def _is_well_formed_route(route: object, /) -> bool:
+    """
+    Get whether a 'routes' element is a well-formed
+    (Ip4Network, Ip4Address) 2-tuple.
+    """
+
+    # Typed 'object' (not the field's 'tuple[Ip4Network, Ip4Address]')
+    # so these are genuine runtime checks, not statically-redundant
+    # ones: a caller may pass a mistyped tuple despite the field
+    # annotation, and it must be rejected here rather than later on
+    # 'network.prefixlen'.
+    return (
+        isinstance(route, tuple)
+        and len(route) == 2
+        and isinstance(route[0], Ip4Network)
+        and isinstance(route[1], Ip4Address)
+    )
+
+
 @dataclass(frozen=True, kw_only=False, slots=True)
 class Dhcp4OptionClasslessStaticRoute(Dhcp4Option):
     """
@@ -101,13 +120,13 @@ def __post_init__(self) -> None:
 
         assert isinstance(self.routes, list), f"The 'routes' field must be a list. Got: {type(self.routes)!r}"
 
-        assert all(
-            isinstance(route, tuple)
-            and len(route) == 2
-            and isinstance(route[0], Ip4Network)
-            and isinstance(route[1], Ip4Address)
-            for route in self.routes
-        ), (
+        # Defensive programmer-error guard: the field is typed
+        # 'list[tuple[Ip4Network, Ip4Address]]', so mypy proves each
+        # 'isinstance' operand statically true, but the runtime check
+        # is load-bearing — a caller passing a wrong-shaped tuple (the
+        # field annotation is advisory, not enforced) must be rejected
+        # here rather than blowing up later on 'network.prefixlen'.
+        assert all(_is_well_formed_route(route) for route in self.routes), (
             f"The 'routes' field must be a list of (Ip4Network, Ip4Address) tuples. "
             f"Got: {[type(route) for route in self.routes]!r}"
         )

packages/net_proto/net_proto/protocols/dhcp6/dhcp6__enums.py

@@ -87,8 +87,10 @@ def __str__(self) -> str:
                 name = "Relay-Forward"
             case Dhcp6MessageType.RELAY_REPL:
                 name = "Relay-Reply"
+            case _:
+                name = f"{self.value}"
 
-        return f"{self.value}" if self.is_unknown else name
+        return name
 
 
 class Dhcp6StatusCode(ProtoEnumWord):
@@ -125,5 +127,7 @@ def __str__(self) -> str:
                 name = "UseMulticast"
             case Dhcp6StatusCode.NO_PREFIX_AVAIL:
                 name = "NoPrefixAvail"
+            case _:
+                name = f"{self.value}"
 
-        return f"{self.value}" if self.is_unknown else name
+        return name

packages/net_proto/net_proto/protocols/dns/dns__enums.py

@@ -63,8 +63,10 @@ def __str__(self) -> str:
                 name = "Notify"
             case DnsOpcode.UPDATE:
                 name = "Update"
+            case _:
+                name = f"{self.value}"
 
-        return f"{self.value}" if self.is_unknown else name
+        return name
 
 
 class DnsResponseCode(ProtoEnumByte):
@@ -98,8 +100,10 @@ def __str__(self) -> str:
                 name = "NotImp"
             case DnsResponseCode.REFUSED:
                 name = "Refused"
+            case _:
+                name = f"{self.value}"
 
-        return f"{self.value}" if self.is_unknown else name
+        return name
 
 
 class DnsRecordType(ProtoEnumWord):
@@ -139,8 +143,10 @@ def __str__(self) -> str:
                 name = "TXT"
             case DnsRecordType.AAAA:
                 name = "AAAA"
+            case _:
+                name = f"{self.value}"
 
-        return f"{self.value}" if self.is_unknown else name
+        return name
 
 
 class DnsRecordClass(ProtoEnumWord):
@@ -165,5 +171,7 @@ def __str__(self) -> str:
                 name = "CH"
             case DnsRecordClass.HS:
                 name = "HS"
+            case _:
+                name = f"{self.value}"
 
-        return f"{self.value}" if self.is_unknown else name
+        return name