crates/vm/src/anystr.rs (1)

412-448: ⚠️ Potential issue | 🔴 Critical

Preserve the “at least one cased character” requirement.

lower / upper is set to true for every successfully compared chunk, so uncased strings now regress to true here. For example, "123".islower() and "🙂".isupper() would both pass this implementation even though CPython returns False. Please derive the flag from actual casedness (for example, by checking that the opposite-case mapping changes the chunk) instead of from chunk presence. A small negative regression test for an all-uncased string would also help.

🐛 Suggested fix

 fn py_islower(&self) -> bool {
-    let mut lower = false;
+    let mut cased = false;
     let mut lowercased = String::with_capacity(self.bytes_len());
+    let mut uppercased = String::with_capacity(self.bytes_len());
     let cm = CaseMapper::new();
     for chunk in self.as_bytes().utf8_chunks().map(|c| c.valid()) {
-        let writer = cm.lowercase(chunk, &LanguageIdentifier::UNKNOWN);
         lowercased.clear();
-        writer
+        cm.lowercase(chunk, &LanguageIdentifier::UNKNOWN)
             .write_to(&mut lowercased)
             .expect("Writing to a buffer is infallible");
         if chunk != lowercased {
             return false;
         }
-        lower = true;
+        uppercased.clear();
+        cm.uppercase(chunk, &LanguageIdentifier::UNKNOWN)
+            .write_to(&mut uppercased)
+            .expect("Writing to a buffer is infallible");
+        cased |= chunk != uppercased;
     }
-    lower
+    cased
 }
 
 fn py_isupper(&self) -> bool {
-    let mut upper = false;
+    let mut cased = false;
     let mut uppercased = String::with_capacity(self.bytes_len());
+    let mut lowercased = String::with_capacity(self.bytes_len());
     let cm = CaseMapper::new();
     for chunk in self.as_bytes().utf8_chunks().map(|c| c.valid()) {
-        let writer = cm.uppercase(chunk, &LanguageIdentifier::UNKNOWN);
         uppercased.clear();
-        writer
+        cm.uppercase(chunk, &LanguageIdentifier::UNKNOWN)
             .write_to(&mut uppercased)
             .expect("Writing to a buffer is infallible");
         if chunk != uppercased {
             return false;
         }
-        upper = true;
+        lowercased.clear();
+        cm.lowercase(chunk, &LanguageIdentifier::UNKNOWN)
+            .write_to(&mut lowercased)
+            .expect("Writing to a buffer is infallible");
+        cased |= chunk != lowercased;
     }
-    upper
+    cased
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/vm/src/anystr.rs` around lines 412 - 448, The current py_islower and
py_isupper set lower/upper true for every chunk processed, causing uncased-only
strings to incorrectly return true; change the flag logic so you only set lower
to true when the chunk is actually cased (e.g., when the uppercase mapping of
the chunk differs from the chunk) and only set upper to true when the lowercase
mapping differs, while preserving the existing equality checks that reject
mixed-case chunks; update py_islower/py_isupper (and use CaseMapper, lowercased,
uppercased, cm) accordingly and add a small negative regression test asserting
that "123" and "🙂" return false for islower/isupper.