fix up more

Author: hauntsaninja

mypy/options.py

@@ -471,9 +471,9 @@ def process_strict_bytes(self) -> None:
             # backwards compatibility
             self.disable_bytearray_promotion = True
             self.disable_memoryview_promotion = True
-        elif self.disable_bytearray_promotion and self.disable_memoryview_promotion:
-            # forwards compatibility
-            self.strict_bytes = True
+        else:
+            self.disable_bytearray_promotion = False
+            self.disable_memoryview_promotion = False
 
     def apply_changes(self, changes: dict[str, object]) -> Options:
         # Note: effects of this method *must* be idempotent.

mypyc/test-data/run-bytes.test

@@ -305,7 +305,7 @@ def test_bytearray_type_object() -> None:
     b = bytearray()
     assert type(b) is bytearray
 
-def fb(b: bytes | bytearray) -> str:
+def fb(b: bytes) -> str:
     return "xy"
 
 def test_bytearray_passed_into_bytes() -> None:

test-data/unit/check-flags.test

@@ -2542,42 +2542,6 @@ x: int = ""  # E: Incompatible types in assignment (expression has type "str", v
 # flags: --hide-error-codes
 x: int = ""  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 
-[case testDisableBytearrayPromotion]
-# flags: --disable-bytearray-promotion --strict-equality --warn-unreachable
-def f(x: bytes) -> None: ...
-f(bytearray(b"asdf"))  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
-f(memoryview(b"asdf"))
-ba = bytearray(b"")
-if ba == b"":
-    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
-if b"" == ba:
-    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
-if ba == bytes():
-    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
-if bytes() == ba:
-    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
-[builtins fixtures/primitives.pyi]
-
-[case testDisableMemoryviewPromotion]
-# flags: --disable-memoryview-promotion
-def f(x: bytes) -> None: ...
-f(bytearray(b"asdf"))
-f(memoryview(b"asdf"))  # E: Argument 1 to "f" has incompatible type "memoryview"; expected "bytes"
-[builtins fixtures/primitives.pyi]
-
-[case testDisableBytearrayMemoryviewPromotionStrictEquality]
-# flags: --strict-equality --strict-bytes
-def f(x: bytes, y: bytearray, z: memoryview) -> None:
-    x == y
-    y == z
-    x == z
-    97 in x
-    97 in y
-    97 in z
-    x in y
-    x in z
-[builtins fixtures/primitives.pyi]
-
 [case testStrictBytes]
 # flags: --strict-bytes
 def f(x: bytes) -> None: ...
@@ -2592,23 +2556,6 @@ f(bytearray(b"asdf"))
 f(memoryview(b"asdf"))
 [builtins fixtures/primitives.pyi]
 
-[case testStrictBytesDisabledByDefault]
-# TODO: probably change this default in Mypy v2.0, with https://github.com/python/mypy/pull/18371
-# (this would also obsolete the testStrictBytesEnabledByStrict test, below)
-def f(x: bytes) -> None: ...
-f(bytearray(b"asdf"))
-f(memoryview(b"asdf"))
-[builtins fixtures/primitives.pyi]
-
-[case testStrictBytesEnabledByStrict]
-# flags: --strict --disable-error-code type-arg
-# The type-arg thing is just work around the primitives.pyi isinstance Tuple not having type parameters,
-#   which isn't important for this.
-def f(x: bytes) -> None: ...
-f(bytearray(b"asdf"))  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
-f(memoryview(b"asdf"))  # E: Argument 1 to "f" has incompatible type "memoryview"; expected "bytes"
-[builtins fixtures/primitives.pyi]
-
 [case testNoCrashFollowImportsForStubs]
 # flags: --config-file tmp/mypy.ini
 {**{"x": "y"}}

test-data/unit/check-type-promotion.test

@@ -33,6 +33,64 @@ def f(x: bytes) -> None: pass
 f(memoryview(b''))
 [builtins fixtures/primitives.pyi]
 
+[case testDisableBytearrayMemoryviewPromotion]
+# flags: --strict-bytes --strict-equality --warn-unreachable
+def f(x: bytes) -> None: ...
+f(bytearray(b"asdf"))  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+f(memoryview(b"asdf"))  # E: Argument 1 to "f" has incompatible type "memoryview"; expected "bytes"
+ba = bytearray(b"")
+if ba == b"":
+    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+if b"" == ba:
+    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+if ba == bytes():
+    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+if bytes() == ba:
+    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+[builtins fixtures/primitives.pyi]
+
+[case testEnableBytearrayMemoryviewPromotion]
+# flags: --no-strict-bytes --strict-equality --warn-unreachable
+def f(x: bytes) -> None: ...
+f(bytearray(b"asdf"))
+f(memoryview(b"asdf"))
+ba = bytearray(b"")
+if ba == b"":
+    f(ba)
+if b"" == ba:
+    f(ba)
+if ba == bytes():
+    f(ba)
+if bytes() == ba:
+    f(ba)
+[builtins fixtures/primitives.pyi]
+
+[case testDisableBytearrayMemoryviewPromotionStrictEquality]
+# flags: --strict-equality --strict-bytes
+def f(x: bytes, y: bytearray, z: memoryview) -> None:
+    x == y
+    y == z
+    x == z
+    97 in x
+    97 in y
+    97 in z
+    x in y
+    x in z
+[builtins fixtures/primitives.pyi]
+
+[case testEnableBytearrayMemoryviewPromotionStrictEquality]
+# flags: --strict-equality --no-strict-bytes
+def f(x: bytes, y: bytearray, z: memoryview) -> None:
+    x == y
+    y == z
+    x == z
+    97 in x
+    97 in y
+    97 in z
+    x in y
+    x in z
+[builtins fixtures/primitives.pyi]
+
 [case testNarrowingDownFromPromoteTargetType]
 y = 0.0
 y = 1