Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

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

444-462: Optional: fold is_cased into a single pass over chars.

Functionally correct and the titlecase rejection addresses the regression flagged on the previous revision. A minor refinement: each chunk is traversed twice (chunk.chars().any(...) for the invalid/titlecase check, then again for the valid check). A single for c in ... loop is a touch more efficient on long strings and mirrors CPython's unicode_islower_impl control flow more directly.

♻️ Proposed single-pass refactor

     fn is_cased<VALID, INVALID>(&self) -> bool
     where
         VALID: BinaryProperty,
         INVALID: BinaryProperty,
     {
         let mut all_cased = false;
-        for chunk in self.as_bytes().utf8_chunks().map(|c| c.valid()) {
-            if chunk.chars().any(|c| {
-                INVALID::for_char(c)
-                    || GeneralCategoryGroup::TitlecaseLetter.contains(GeneralCategory::for_char(c))
-            }) {
-                return false;
-            }
-            if !all_cased && chunk.chars().any(VALID::for_char) {
-                all_cased = true;
-            }
+        for c in self
+            .as_bytes()
+            .utf8_chunks()
+            .flat_map(|c| c.valid().chars())
+        {
+            if INVALID::for_char(c)
+                || GeneralCategoryGroup::TitlecaseLetter.contains(GeneralCategory::for_char(c))
+            {
+                return false;
+            }
+            if !all_cased && VALID::for_char(c) {
+                all_cased = true;
+            }
         }
         all_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 444 - 462, The current is_cased
implementation iterates each utf8 chunk twice (once to check
INVALID::for_char/TitlecaseLetter via GeneralCategory::for_char and again to
check VALID::for_char), so refactor is_cased to perform a single pass: for each
chunk from self.as_bytes().utf8_chunks().map(|c| c.valid()) iterate each char
once, immediately return false if INVALID::for_char(c) or
GeneralCategoryGroup::TitlecaseLetter.contains(GeneralCategory::for_char(c)) is
true, and otherwise set a flag when VALID::for_char(c) is seen; after processing
all chunks return that flag. Keep the same trait bounds (VALID: BinaryProperty,
INVALID: BinaryProperty) and behavior.

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

441-465: is_cased now faithfully mirrors CPython's unicode_is{upper,lower}_impl (titlecase regression fixed).

The previous concern about titlecase code points (e.g. "\u01c5A".isupper() returning true) is resolved by the GeneralCategoryGroup::TitlecaseLetter.contains(GeneralCategory::for_char(c)) guard, which is equivalent to CPython's Py_UNICODE_ISTITLE (set on Lt). The control flow — early-return false on INVALID or titlecase, set all_cased once on VALID, return all_cased — matches CPython line-for-line.

The as_bytes().utf8_chunks().flat_map(|c| c.valid().chars()) pattern is the right choice for the Wtf8 impl too: isolated surrogates are dropped, but since surrogates are never Lu/Ll/Lt in CPython either, the observable behavior is identical.

Optional readability nit (non-blocking): the titlecase test could be written more directly, in line with the nearby isdecimal style on str.rs:

♻️ Optional tweak

-            if INVALID::for_char(c)
-                || GeneralCategoryGroup::TitlecaseLetter.contains(GeneralCategory::for_char(c))
-            {
+            if INVALID::for_char(c)
+                || matches!(GeneralCategory::for_char(c), GeneralCategory::TitlecaseLetter)
+            {
                 return false;
             }

This also lets you drop GeneralCategoryGroup from the imports at the top of the file if no other user remains.

🤖 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 441 - 465, Replace the Titlecase guard
in is_cased to check the GeneralCategory directly (e.g. compare
GeneralCategory::for_char(c) to the TitlecaseLetter variant or call a dedicated
is_titlecase method) instead of using
GeneralCategoryGroup::TitlecaseLetter.contains(...); update the import list to
remove GeneralCategoryGroup if unused (keep GeneralCategory) so the check
mirrors the nearby isdecimal style and removes the extra import.

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

444-465: is_cased correctly rejects opposite-case and titlecase — matches CPython.

The titlecase rejection (previously flagged) is now in place, so strings like "DžA".isupper() and "Dža".islower() will return false as CPython does.

Two minor notes:

1. The titlecase test is slightly indirect — a direct equality is clearer and avoids constructing a group:

♻️ Optional simplification

-            if INVALID::for_char(c)
-                || GeneralCategoryGroup::TitlecaseLetter.contains(GeneralCategory::for_char(c))
-            {
+            if INVALID::for_char(c) || GeneralCategory::for_char(c) == GeneralCategory::TitlecaseLetter {
                 return false;
             }

2. For Wtf8, unpaired surrogates are encoded as invalid UTF-8 bytes and get skipped by utf8_chunks().flat_map(|c| c.valid().chars()). Surrogates aren't cased, so this is semantically fine, but worth a brief comment so future readers don't mistake the chunking for a bug.

🤖 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 444 - 465, The is_cased function should
use a direct titlecase comparison and document surrogate behavior: replace the
indirect
GeneralCategoryGroup::TitlecaseLetter.contains(GeneralCategory::for_char(c))
with an equality check GeneralCategory::for_char(c) ==
GeneralCategory::TitlecaseLetter inside is_cased (keeping the early return where
INVALID::for_char(c) triggers false), and add a short comment near the
utf8_chunks().flat_map(...) explaining that Wtf8 encodes unpaired surrogates as
invalid UTF‑8 bytes which are skipped by utf8_chunks so surrogates won’t be
seen/cased; reference the is_cased function and the VALID/INVALID,
GeneralCategory, and utf8_chunks symbols when making the change.

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

455-457: Prefer direct GeneralCategory equality over group containment for single-category checks.

GeneralCategoryGroup::TitlecaseLetter is a single-category group, so .contains(...) is unnecessary. The codebase already uses this pattern in str.rs with matches!(GeneralCategory::for_char(c), GeneralCategory::DecimalNumber) for equivalent checks.

♻️ Proposed tweak

-            if INVALID::for_char(c)
-                || GeneralCategoryGroup::TitlecaseLetter.contains(GeneralCategory::for_char(c))
-            {
+            if INVALID::for_char(c)
+                || GeneralCategory::for_char(c) == GeneralCategory::TitlecaseLetter
+            {
                 return false;
             }

After this change, GeneralCategoryGroup can be removed from the import list at lines 7–9, as it has no other uses in this file.

🤖 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 455 - 457, The code uses
GeneralCategoryGroup::TitlecaseLetter.contains(GeneralCategory::for_char(c)) for
a single-category check; replace that containment call with a direct
GeneralCategory comparison (e.g., match or matches! against
GeneralCategory::TitlecaseLetter) alongside the existing INVALID::for_char(c)
check in the same if, and then remove GeneralCategoryGroup from the imports
(it's no longer used in this file); update the condition that currently reads
GeneralCategoryGroup::TitlecaseLetter.contains(GeneralCategory::for_char(c)) to
use direct equality/matching against GeneralCategory::TitlecaseLetter.