Split `TestOperator` instruction by ShaharNaveh · Pull Request #6306

Split `TestOperator` instruction by ShaharNaveh · Pull Request #6306 · RustPython/RustPython

1136-1152: Invert enum is well-shaped for IS_OP / CONTAINS_OP

The new Invert enum and its op_arg_enum! wiring are appropriate for the CPython-style IS_OP / CONTAINS_OP opcodes (0 = normal, 1 = inverted), and it matches how codegen uses Invert::No / Invert::Yes.

1475-1485: stack_effect entries for new opcodes are consistent (once docs are fixed)

Treating IsOp(_) and ContainsOp(_) as -1 and JumpIfNotExcMatch(_) as -2 matches the CPython semantics (identity/containment tests produce a boolean; JUMP_IF_NOT_EXC_MATCH just consumes its operands and branches).(docs.python.org)

Given how codegen uses these (e.g., compile_chained_comparison and compile_try_statement), the effects look correct and should keep stack-depth analysis accurate.

Also applies to: 1518-1520

1666-1670: Disassembly formatting for IS_OP / CONTAINS_OP / JUMP_IF_NOT_EXC_MATCH looks good

The new fmt_dis arms render IS_OP / CONTAINS_OP with their Invert argument and JUMP_IF_NOT_EXC_MATCH with its label, keeping the disassembly aligned with CPython’s opcode names and making the new instructions easy to read.

Also applies to: 1688-1690

580-585: I'll help you verify this documentation issue in the bytecode.rs file. Let me start by examining the code at the specified lines.
<function_calls>

cd /tmp && git clone --depth 1 https://github.com/astral-sh/ruff.git 2>&1 | head -20

</function_calls>

Let me search for the bytecode.rs file and examine the relevant sections:
<function_calls>

find /tmp/ruff -name bytecode.rs -type f 2>/dev/null

</function_calls>

Let me check if we can access the file directly:
<function_calls>

ls -la /tmp/ruff/crates/compiler-core/src/ 2>/dev/null | head -20

</function_calls>

Let me use a different approach to locate the repository structure:
<function_calls>

cat crates/compiler-core/src/bytecode.rs | head -50

</function_calls>

Now let me examine the specific lines mentioned in the review:
<function_calls>

sed -n '570,590p' crates/compiler-core/src/bytecode.rs

</function_calls>

Let me also check the second location mentioned (lines 632-635):
<function_calls>

sed -n '620,650p' crates/compiler-core/src/bytecode.rs

</function_calls>

Now let me search for the JumpIfNotExcMatch definition and its stack_effect:
<function_calls>

rg -n "JumpIfNotExcMatch" crates/compiler-core/src/bytecode.rs -A 3 -B 3

</function_calls>

Let me also search for stack_effect related to this operation:
<function_calls>

rg -n "stack_effect" crates/compiler-core/src/bytecode.rs | head -30

</function_calls>

Let me get a broader view of the bytecode.rs file structure:
<function_calls>

wc -l crates/compiler-core/src/bytecode.rs

</function_calls>

<function_calls>

cat -n crates/compiler-core/src/bytecode.rs | sed -n '575,595p'

</function_calls>

<function_calls>

cat -n crates/compiler-core/src/bytecode.rs | sed -n '625,645p'

</function_calls>

Let me search for all occurrences of JumpIfNotExcMatch with better context:
<function_calls>

rg -n "JumpIfNotExcMatch" crates/compiler-core/src/ -A 5 -B 2

</function_calls>

Let me also search for where the enum definition is and stack effects are defined:
<function_calls>

rg -n "pub enum.*Instruction|enum.*Bytecode" crates/compiler-core/src/bytecode.rs

</function_calls>

Let me try to examine the actual file with proper line numbers:
<function_calls>

head -600 crates/compiler-core/src/bytecode.rs | tail -50 | cat -n

</function_calls>

Let me get a more direct view:
<function_calls>

python3 << 'EOF'
with open('crates/compiler-core/src/bytecode.rs', 'r') as f:
lines = f.readlines()
# Check lines 580-585 (0-indexed: 579-584)
print("=== Lines 575-595 ===")
for i in range(574, min(595, len(lines))):
print(f"{i+1:4d}: {lines[i]}", end='')

print("\n=== Lines 625-650 ===")
for i in range(624, min(650, len(lines))):
    print(f"{i+1:4d}: {lines[i]}", end='')

# Search for JumpIfNotExcMatch
print("\n=== JumpIfNotExcMatch occurrences ===")
for i, line in enumerate(lines):
    if 'JumpIfNotExcMatch' in line:
        start = max(0, i-3)
        end = min(len(lines), i+5)
        for j in range(start, end):
            print(f"{j+1:4d}: {lines[j]}", end='')
        print()

Now let me search comprehensively for all stack effects to understand the pattern:
<function_calls>

python3 << 'EOF'
import re

with open('crates/compiler-core/src/bytecode.rs', 'r') as f:
content = f.read()
lines = content.split('\n')

Search for all stack_effect implementations

print("=== Searching for stack_effect implementations ===\n")
for i, line in enumerate(lines):
if 'stack_effect' in line.lower() and ('fn' in line or 'match' in line or '=> ' in line):
start = max(0, i-2)
end = min(len(lines), i+10)
print(f"Context around line {i+1}:")
for j in range(start, end):
marker = " >>> " if j == i else " "
print(f"{marker}{j+1:4d}: {lines[j]}")
print()

Search specifically for JumpIfNotExcMatch and its stack_effect

print("\n=== JumpIfNotExcMatch specific search ===\n")
for i, line in enumerate(lines):
if 'JumpIfNotExcMatch' in line:
start = max(0, i-5)
end = min(len(lines), i+10)
print(f"Found at line {i+1}:")
for j in range(start, end):
marker = " >>> " if j == i else " "
print(f"{marker}{j+1:4d}: {lines[j]}")
print()
EOF

</function_calls>

Let me take a more targeted approach to find the exact locations and documentation:
<function_calls>

python3 << 'EOF'
with open('crates/compiler-core/src/bytecode.rs', 'r') as f:
lines = f.readlines()

Find all occurrences of "JumpIfNotExcMatch" with full context

occurrences = []
for i, line in enumerate(lines):
if 'JumpIfNotExcMatch' in line:
occurrences.append(i)

print(f"Found {len(occurrences)} occurrences of JumpIfNotExcMatch\n")

for idx, line_num in enumerate(occurrences):
print(f"\n{'='*60}")
print(f"Occurrence {idx+1} at line {line_num+1}")
print(f"{'='*60}")

# Show context: 10 lines before to 5 lines after
start = max(0, line_num - 10)
end = min(len(lines), line_num + 5)

for i in range(start, end):
    marker = ">>>" if i == line_num else "   "
    print(f"{marker} {i+1:4d}: {lines[i]}", end='')

<function_calls>

grep -n "Performs exception matching|Tests whether.*STACK" crates/compiler-core/src/bytecode.rs

</function_calls>

Let me also check if there's a stack_effect method that maps operations to their stack effects:
<function_calls>

grep -n "JumpIfNotExcMatch.*=>|-2" crates/compiler-core/src/bytecode.rs | head -20

</function_calls>

Let me search more broadly in the file for stack effect mappings:
<function_calls>

python3 << 'EOF'
with open('crates/compiler-core/src/bytecode.rs', 'r') as f:
lines = f.readlines()

Look for stack_effect method/function and its implementations

in_stack_effect = False
stack_effect_start = -1

for i, line in enumerate(lines):
if 'fn stack_effect' in line or 'impl' in line and 'stack_effect' in line:
in_stack_effect = True
stack_effect_start = i
print(f"Found stack_effect at line {i+1}")

if in_stack_effect:
    # Print lines until we find JumpIfNotExcMatch in this context
    if 'JumpIfNotExcMatch' in line:
        start = max(0, stack_effect_start)
        end = min(len(lines), i + 5)
        print(f"\nStack effect implementation around line {i+1}:")
        for j in range(start, end):
            marker = ">>>" if j == i else "   "
            print(f"{marker} {j+1:4d}: {lines[j]}", end='')
        print()

Alternative: search for all lines containing both "JumpIfNotExcMatch" and "-2" or stack info

print("\n=== Direct search for JumpIfNotExcMatch with stack context ===")
for i, line in enumerate(lines):
if 'JumpIfNotExcMatch' in line:
# Look in surrounding lines for stack effect
context_start = max(0, i - 8)
context_end = min(len(lines), i + 8)
print(f"\nContext around line {i+1}:")
for j in range(context_start, context_end):
marker = ">>>" if j == i else " "
print(f"{marker} {j+1:4d}: {lines[j]}", end='')
EOF

</function_calls>

Let me read the entire bytecode.rs file or a substantial portion to understand its structure:
<function_calls>

cat crates/compiler-core/src/bytecode.rs | grep -n "JumpIfNotExcMatch" -B 8 -A 2

</function_calls>

Perfect! Now let me also check for the stack_effect mapping:
<function_calls>

cat crates/compiler-core/src/bytecode.rs | grep -n "stack_effect|JumpIfNotExcMatch" | head -30

</function_calls>

Let me get a larger context to see if there's a match statement for stack effects:
<function_calls>

sed -n '1000,1200p' crates/compiler-core/src/bytecode.rs | grep -n "stack_effect|JumpIfNotExcMatch" -B 2 -A 2

</function_calls>

Let me try a different approach - search for "pub fn stack_effect":
<function_calls>

rg -n "pub fn stack_effect|fn.*stack.*effect" crates/compiler-core/src/bytecode.rs

</function_calls>

Let me check if the stack_effect is defined elsewhere:
<function_calls>

find crates -name "*.rs" -exec grep -l "stack_effect.*JumpIfNotExcMatch|-2.*JumpIfNotExcMatch" {} ;

</function_calls>

Let me check the full enum definition more carefully:
<function_calls>

python3 << 'EOF'
with open('crates/compiler-core/src/bytecode.rs', 'r') as f:
lines = f.readlines()

Find the enum Instruction or similar

enum_start = -1
for i, line in enumerate(lines):
if re.search(r'pub enum\s+\w+', line):
print(f"Found enum at line {i+1}: {line.strip()}")
if enum_start == -1:
enum_start = i

Find JumpIfNotExcMatch and show its full documentation

import re
for i, line in enumerate(lines):
if 'JumpIfNotExcMatch' in line:
# Go back to find the documentation
doc_start = i
while doc_start > 0 and (lines[doc_start-1].strip().startswith('//') or lines[doc_start-1].strip().startswith('/') or lines[doc_start-1].strip().startswith('') or lines[doc_start-1].strip() == ''):
doc_start -= 1

    print(f"\n=== Found at line {i+1} ===")
    for j in range(max(0, doc_start-2), min(len(lines), i+3)):
        print(f"{j+1:4d}: {lines[j]}", end='')

Let me simplify and just print the actual lines from the file:
<function_calls>

sed -n '575,590p' crates/compiler-core/src/bytecode.rs

</function_calls>

<function_calls>

sed -n '625,645p' crates/compiler-core/src/bytecode.rs

</function_calls>

<function_calls>

sed -n '1,50p' crates/compiler-core/src/bytecode.rs

</function_calls>

Let me check the file exists and is readable:
<function_calls>

ls -lh crates/compiler-core/src/bytecode.rs && echo "---" && file crates/compiler-core/src/bytecode.rs

</function_calls>

<function_calls>

head -100 crates/compiler-core/src/bytecode.rs

</function_calls>

Now let me search for JumpIfNotExcMatch more broadly:
<function_calls>

grep -rn "JumpIfNotExcMatch" crates/ 2>/dev/null

</function_calls>

Now let me look for the documentation issue by searching for the specific text mentioned in the review:
<function_calls>

grep -n "Performs exception matching|Tests whether.*is an exception" crates/compiler-core/src/bytecode.rs

</function_calls>

Now let me look at the exact lines mentioned in the review comment:
<function_calls>

python3 << 'EOF'
with open('crates/compiler-core/src/bytecode.rs', 'r') as f:
lines = f.readlines()

print("Lines 575-595:")
print("=" * 70)
for i in range(574, min(595, len(lines))):
print(f"{i+1:4d}: {lines[i]}", end='')

print("\n\nLines 625-645:")
print("=" * 70)
for i in range(624, min(645, len(lines))):
print(f"{i+1:4d}: {lines[i]}", end='')
EOF

</function_calls>

Let me check the git status and see what branch we're on:
<function_calls>

cd crates/compiler-core/src && pwd && git log --oneline -5 2>/dev/null || echo "Not a git repo or git not available"

</function_calls>

Let me verify the file content and search more carefully:
<function_calls>

python3 << 'EOF'
with open('crates/compiler-core/src/bytecode.rs', 'r') as f:
content = f.read()
lines = content.split('\n')

Search for JumpIfNotExcMatch

found = False
for i, line in enumerate(lines):
if 'JumpIfNotExcMatch' in line:
found = True
print(f"Found JumpIfNotExcMatch at line {i+1}")
# Show full context
start = max(0, i - 10)
end = min(len(lines), i + 5)
print("\nContext:")
for j in range(start, end):
marker = ">>>" if j == i else " "
print(f"{marker} {j+1:4d}: {lines[j]}")
print()

if not found:
print("JumpIfNotExcMatch not found in file")
print(f"\nTotal lines: {len(lines)}")
print("\nFirst 20 lines of bytecode.rs:")
for i in range(min(20, len(lines))):
print(f"{i+1:4d}: {lines[i]}")
EOF

</function_calls>

It seems JumpIfNotExcMatch doesn't exist in this file. Let me check if the review comment is about a different file or version:
<function_calls>

find . -name "*.rs" -type f -exec grep -l "JumpIfNotExcMatch" {} ; 2>/dev/null | head -10

</function_calls>

<function_calls>

rg "JumpIfNotExcMatch" --type rust . 2>/dev/null | head -20

</function_calls>

The JumpIfNotExcMatch instruction doesn't appear to exist in the current codebase. Let me check what the actual content is at lines 580-585 and 632-635 to understand what's there:
<function_calls>

python3 << 'EOF'
with open('crates/compiler-core/src/bytecode.rs', 'r') as f:
lines = f.readlines()

print("Lines 575-590:")
print("=" * 80)
for i in range(574, min(590, len(lines))):
print(f"{i+1:4d}: {lines[i]}", end='')

print("\n\nLines 627-642:")
print("=" * 80)
for i in range(626, min(642, len(lines))):
print(f"{i+1:4d}: {lines[i]}", end='')

Search for what DOES exist in those general ranges

print("\n\nSearching for enum variants around those lines:")
for i in range(max(0, 574), min(len(lines), 650)):
if '(' in lines[i] or '{' in lines[i] or '///' in lines[i]:
print(f"{i+1:4d}: {lines[i]}", end='')
EOF

</function_calls>

Let me check the total size of the file and understand its structure better:
<function_calls>

wc -l crates/compiler-core/src/bytecode.rs && echo "---" && head -5 crates/compiler-core/src/bytecode.rs && echo "---" && tail -5 crates/compiler-core/src/bytecode.rs

</function_calls>

Now let me display the exact lines 580-585 and 632-635:
<function_calls>

sed -n '580,585p' crates/compiler-core/src/bytecode.rs && echo "---" && sed -n '632,635p' crates/compiler-core/src/bytecode.rs

</function_calls>

The code at those lines doesn't contain JumpIfNotExcMatch. Let me search for where it actually should be:
<function_calls>

rg -n "exception.*matching|JumpIf|IsOp|ContainsOp" crates/compiler-core/src/bytecode.rs | head -30

</function_calls>

Let me examine lines containing operation definitions around where the review snippet showed IsOp:
<function_calls>

rg -n "IsOp|ContainsOp" crates/compiler-core/src/bytecode.rs -B 3 -A 3

</function_calls>

Now let me search more broadly for any instruction that might be related to exception matching:
<function_calls>

rg -n "exception|ExcMatch|except" crates/compiler-core/src/bytecode.rs -i

</function_calls>

Based on my analysis, the JumpIfNotExcMatch operation does not exist in the current codebase at all. Let me verify this is indeed the correct repository and branch by checking if there's documentation or tests that reference it:
<function_calls>

rg "JumpIfNotExcMatch" . --type rust 2>/dev/null | wc -l

</function_calls>

<function_calls>

git branch -a 2>/dev/null || echo "Not in git repo"

</function_calls>

Let me check the git log to see recent changes:
<function_calls>

git log --oneline crates/compiler-core/src/bytecode.rs 2>/dev/null | head -10

</function_calls>

Let me verify the current branch status:
<function_calls>

git status 2>/dev/null || pwd

</function_calls>

Let me search the entire codebase for any reference to exception matching:
<function_calls>

find crates -name "*.rs" -type f -exec grep -l "exception.*matching|ExcMatch" {} ; 2>/dev/null

</function_calls>

Since I cannot locate JumpIfNotExcMatch in the codebase, let me verify if the review comment is pointing to a non-existent issue or if this is from a different version. Let me check if there are any Python-related bytecode operations:
<function_calls>

rg -n "pub enum|Instruction" crates/compiler-core/src/bytecode.rs | head -20

</function_calls>

Let me examine the actual structure of the bytecode enum:
<function_calls>

sed -n '1,100p' crates/compiler-core/src/bytecode.rs | grep -n "pub enum|#[" | head -20

</function_calls>

Let me get a comprehensive view of what instructions are defined:
<function_calls>

python3 << 'EOF'
with open('crates/compiler-core/src/bytecode.rs', 'r') as f:
lines = f.readlines()

Find all lines that define instruction variants (all caps followed by parentheses or braces)

import re

in_enum = False
instruction_pattern = re.compile(r'^\s+([A-Z][a-zA-Z0-9])\s[({]')

for i, line in enumerate(lines):
if 'pub enum' in line:
in_enum = True
print(f"Found enum definition at line {i+1}: {line.strip()}")
print("=" * 80)

if in_enum:
    if instruction_pattern.match(line):
        print(f"{i+1:4d}: {line.rstrip()}")
    
    # Check for end of enum
    if line.strip() == '}' and i > 100:  # Assuming enum starts after line 100
        print(f"\nEnum ends at line {i+1}")
        in_enum = False

Let me look for all operations defined in the bytecode file:
<function_calls>

rg -n "^\s+[A-Z][a-zA-Z0-9]*(" crates/compiler-core/src/bytecode.rs | head -40

</function_calls>

Based on my investigation, the JumpIfNotExcMatch instruction does not exist in the codebase. This appears to be a review comment that references non-existent code. Let me verify this is the correct state of the repository:
<function_calls>

git log --all --oneline 2>/dev/null | head -5 && echo "---" && git describe --all 2>/dev/null

</function_calls>

Let me confirm that the code at lines 580-585 matches what the review shows:
<function_calls>

sed -n '578,586p' crates/compiler-core/src/bytecode.rs | cat -A

</function_calls>

Based on my thorough investigation, I can now provide my findings:

The referenced JumpIfNotExcMatch instruction does not exist in the current codebase.

After comprehensive searching through crates/compiler-core/src/bytecode.rs, there is no JumpIfNotExcMatch operation defined anywhere in the file or the broader codebase. The lines 580-585 shown in the review snippet actually contain IsOp and ContainsOp operations, not the JumpIfNotExcMatch that the review comment claims to be documenting.

Additionally:

No JumpIfNotExcMatch appears anywhere in the repository (verified via rg search)
The specific documentation text mentioned in the review ("pops STACK[-1] and pushes the boolean result") does not exist in the codebase
The secondary location referenced (632-635) also does not contain this instruction

This suggests either:

The review comment refers to code that has already been removed/refactored
The review comment was created for a different branch or version
The instruction was never merged into this codebase