Fix error code precedence to ensure disable overrides enable

The logic for resolving conflicts between 'enable_error_code' and
'disable_error_code' was inverted in two locations: Options.process_error_codes
and Options.apply_changes.

In the global configuration path, enabling incorrectly won precedence. In
the per-module override path, the logic allowed inherited enabling to
undo an explicit disabling.

This change swaps the set subtraction in process_error_codes and removes
the redundant discard operation in apply_changes to enforce the rule:
Disable always wins.

Fixes #20348.

Author: franzengel04

mypy/options.py

@@ -85,7 +85,9 @@ class BuildType:
 NEW_GENERIC_SYNTAX: Final = "NewGenericSyntax"
 INLINE_TYPEDDICT: Final = "InlineTypedDict"
 TYPE_FORM: Final = "TypeForm"
-INCOMPLETE_FEATURES: Final = frozenset((PRECISE_TUPLE_TYPES, INLINE_TYPEDDICT, TYPE_FORM))
+INCOMPLETE_FEATURES: Final = frozenset(
+    (PRECISE_TUPLE_TYPES, INLINE_TYPEDDICT, TYPE_FORM)
+)
 COMPLETE_FEATURES: Final = frozenset((TYPE_VAR_TUPLE, UNPACK, NEW_GENERIC_SYNTAX))
 
 
@@ -468,10 +470,14 @@ def process_error_codes(self, *, error_callback: Callable[[str], Any]) -> None:
         self.enabled_error_codes |= {error_codes[code] for code in enabled_codes}
 
         # Enabling an error code always overrides disabling
-        self.disabled_error_codes -= self.enabled_error_codes
+        # The original line: self.disabled_error_codes -= self.enabled_error_codes
+        self.enabled_error_codes -= self.disabled_error_codes
 
     def process_incomplete_features(
-        self, *, error_callback: Callable[[str], Any], warning_callback: Callable[[str], Any]
+        self,
+        *,
+        error_callback: Callable[[str], Any],
+        warning_callback: Callable[[str], Any],
     ) -> None:
         # Validate incomplete features.
         for feature in self.enable_incomplete_feature:
@@ -513,7 +519,8 @@ def apply_changes(self, changes: dict[str, object]) -> Options:
         for code_str in new_options.enable_error_code:
             code = error_codes[code_str]
             new_options.enabled_error_codes.add(code)
-            new_options.disabled_error_codes.discard(code)
+            # Fix: Remove the next line to ensure 'disabled' takes precedence.
+            # Original line: new_options.disabled_error_codes.discard(code)
         return new_options
 
     def compare_stable(self, other_snapshot: dict[str, object]) -> bool:
@@ -545,8 +552,12 @@ def build_per_module_cache(self) -> None:
         # than foo.bar.*.
         # (A section being "processed last" results in its config "winning".)
         # Unstructured glob configs are stored and are all checked for each module.
-        unstructured_glob_keys = [k for k in self.per_module_options.keys() if "*" in k[:-1]]
-        structured_keys = [k for k in self.per_module_options.keys() if "*" not in k[:-1]]
+        unstructured_glob_keys = [
+            k for k in self.per_module_options.keys() if "*" in k[:-1]
+        ]
+        structured_keys = [
+            k for k in self.per_module_options.keys() if "*" not in k[:-1]
+        ]
         wildcards = sorted(k for k in structured_keys if k.endswith(".*"))
         concrete = [k for k in structured_keys if not k.endswith(".*")]
 
@@ -564,7 +575,9 @@ def build_per_module_cache(self) -> None:
             # on inheriting from parent configs.
             options = self.clone_for_module(key)
             # And then update it with its per-module options.
-            self._per_module_cache[key] = options.apply_changes(self.per_module_options[key])
+            self._per_module_cache[key] = options.apply_changes(
+                self.per_module_options[key]
+            )
 
         # Add the more structured sections into unused configs, since
         # they only count as used if actually used by a real module.

mypyc/test/test_options.py

@@ -0,0 +1,55 @@
+# test/testopts.py (or similar file)
+
+from mypy.errorcodes import error_codes, ErrorCode
+from mypy.options import Options
+import unittest # or another framework used by mypy
+
+# Get the specific ErrorCode object we are testing
+POSSIBLY_UNDEFINED = error_codes['possibly-undefined']
+
+class OptionsPrecedenceSuite(unittest.TestCase):
+    # ... other test methods ...
+
+    # --- Your New Tests Below ---
+
+    def test_global_disable_precedence(self) -> None:
+        """
+        Verify fix #1: Global disable via flag/config overrides global enable.
+        (Tests Options.process_error_codes)
+        """
+        options = Options()
+        # 1. Simulate both being set in config/command line
+        options.enable_error_code = ['possibly-undefined']
+        options.disable_error_code = ['possibly-undefined']
+
+        # 2. Run the processing logic (this is where your fix lives)
+        options.process_error_codes(error_callback=lambda x: None)
+
+        # 3. Assert the result: DISABLE must win
+        self.assertIn(POSSIBLY_UNDEFINED, options.disabled_error_codes)
+        self.assertNotIn(POSSIBLY_UNDEFINED, options.enabled_error_codes)
+
+    def test_per_module_disable_precedence(self) -> None:
+        """
+        Verify fix #2: Per-module disable overrides global enable.
+        (Tests Options.apply_changes)
+        """
+        base_options = Options()
+        
+        # 1. Setup the global options to ENABLE the code
+        base_options.enable_error_code = ['possibly-undefined']
+        base_options.process_error_codes(error_callback=lambda x: None)
+        
+        # 2. Setup a per-module override to DISABLE the code
+        per_module_changes = {
+            'disable_error_code': ['possibly-undefined'],
+            'enable_error_code': [], # ensure this list doesn't interfere
+        }
+        
+        # 3. Apply the per-module changes (this is where your fix lives)
+        # We don't care about the module name here, just the application of changes.
+        module_options = base_options.apply_changes(per_module_changes)
+        
+        # 4. Assert the result: DISABLE must win at the module level
+        self.assertIn(POSSIBLY_UNDEFINED, module_options.disabled_error_codes)
+        self.assertNotIn(POSSIBLY_UNDEFINED, module_options.enabled_error_codes)