hSrSSKJr SSKrSSKrSSKJr SSKJr SSK J r J r SSK J r Jr SSjrSS jr\"S S S 5r\"S S5r\"SS5r"SS5r\\ \ \\4r\\\4rSSjrSSjrg)z!Bytecode analysis for coverage.py) annotationsN)Iterator)CodeType)IterableOptional)TArcTOffsetc## U/nU(aYUR5nURH+n[U[5(dMUR U5 M- Uv U(aMXgg7f)z,Iterate over all the code objects in `code`.N)pop co_consts isinstancerappend)codestackcs o/root/racknerd_01/codex-conversation/amazon-q-terraform/.venv/lib/python3.13/site-packages/coverage/bytecode.py code_objectsrsP FE yy{A!X&& Q   %s=A' A'%A'cUVs1sH-n[RRU5=n(dM+UiM/ sn$s snf)zwMake a set of opcodes from instruction names. The names might not exist in this version of Python, skip those if not. )disopmapget)op_namesnameops rop_setrs3 $ C84ciimmD.A(A(AB8 CC Cs*<< JUMP_BACKWARDJUMP_BACKWARD_NO_INTERRUPT JUMP_FORWARD RETURN_VALUERETURN_GENERATORNOP NOT_TAKENc@\rSrSrSrS SjrSSS.S SjjrSrg ) InstructionWalker:aIUtility to step through trails of instructions. We have two reasons to need sequences of instructions from a code object: First, in strict sequence to visit all the instructions in the object. This is `walk(follow_jumps=False)`. Second, we want to follow jumps to understand how execution will flow: `walk(follow_jumps=True)`. cXl0UlSn[R"U5HnX RUR'M UceURUlgN)rinstsrget_instructionsoffset max_offset)selfrinsts r__init__InstructionWalker.__init__CsQ 57 ((.D&*JJt{{ #/++rTstart_at follow_jumpsc#H# [5nUnX@RS-:aXC;agURU5 URR U5=n(a-Uv U(a"UR [ ;aURnMxUS- nX@RS-:aMgg7f)ze Yield instructions starting from `start_at`. Follow unconditional jumps if `follow_jumps` is true. N)setr+addr(ropcode ALWAYS_JUMPS jump_target)r,r2r3seenr*r-s rwalkInstructionWalker.walkNsu**~ HHV zz~~f--t- DKK<$?!--F aKF**s BB" B")rr(r+N)rrreturnNone)r2r r3boolr?zIterable[dis.Instruction])__name__ __module__ __qualname____firstlineno____doc__r.r=__static_attributes__r0rr$r$:s5 &&'T"6: "r0r$c^^^ [R"S5n[T5m T RSS9HnUR(dMUR [ ;aM,URmTcM=SUUU 4Sjjn[R"[5nU"XBRS-S9 U"XBRS9 XAUR'UR5H$upVUHnXURU5 M M& M U$)av Calculate branch trails for `code`. Instructions can have a jump_target, where they might jump to next. Some instructions with a jump_target are unconditional jumps (ALWAYS_JUMPS), so they aren't interesting to us, since they aren't the start of a branch possibility. Instructions that might or might not jump somewhere else are branch possibilities. For each of those, we track a trail of instructions. These are lists of instruction offsets, the next instructions that can execute. We follow the trail until we get to a new source line. That gives us the arc from the original instruction's line to the new source line. c6[R"[5$r') collections defaultdictr7rHr0rbranch_trails..ws @W@WX[@\r0Fr3c>[5nSnTRUSS9HnURUR5 UR(aURT:waURn ONUR (aUR [;a O'UR [;dMTR*n O UbUTU4RU5 g[5US'g)NTr1) r7r=r8r* line_numberr;r9r:RETURNSco_firstlinenoupdate)trailsr2 inst_offsetsto_lineinst2r from_lineiwalkers radd_one_branch_trail+branch_trails..add_one_branch_trails *-LG xdK  .$$):):i)G#//G&&ELL ,L\\W,#222GL" 7+,33LA"ut r0r6)r2)rUTBranchTrailsOneSourcer2r r?r@) rKrLr$r=r;r9r:rQr7r*itemsrT) r the_trailsr-r[rUarcoffsetsr*rYrZs ` @@r branch_trailsrbgs !, 7 78\ ]J%G % 0  ;;, & $$    %* % % % %0*5)@)@)EVkkAo>V.>.>?"(4;; #LLNLC!"3'..w7"+[1b r0c 0n[U5nURSS9HbnUR[;aURXR 'M1UR[ ;dMGUR S-XR 'Md U$)z}Make a map of unconditional bytecodes jumping to others. Only include bytecodes that do no work and go to another bytecode. FrOr6)r$r=r9r:r;r*NOPS)rjumpsrZr-s r always_jumpsrfsm E%G % 0 ;;, &!%!1!1E++  [[D !%qE++  1 Lr0)rrr?zIterator[CodeType])rstrr?zset[int])rrr? TBranchTrails)rrr?zdict[TOffset, TOffset])rF __future__rrKrcollections.abcrtypesrtypingrrcoverage.typesrr rrr:rRrdr$dictr7r]rhrbrfrHr0rros(" $%( D       &&Rhtnc'l:;W445 CL r0