oPjBdZddlmZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z ddl mZddlmZmZddlmZddlmZdd lmZdd lmZmZdd lmZmZdd lmZm Z dd l!m"Z"m#Z#eeZd%dZ$d&dZ%GddZ&eddGddZ'GddeZ(e)e"e*e+e,dze,dzffZ-GddZ.Gdde.Z/Gdde.Z0Gdde.Z1ejdejfejhfZ5d'd Z6d(d!Z7d)d"Z8Gd#d$Z9y)*zCode parsing for coverage.py.) annotationsN)CallableIterableSequence) dataclass)Protocolcast)env) ByteParser) short_stack)NoSource NotPython)isolate_module nice_pair)TTokengenerate_tokens)TArcTLineNoci}d}|D]m\}}\}}\}}}|tjk(r"|r||k7rt||dzD]}|||< d}|jsU|tj k7si|rl|}o|S)aCompute the multiline map from a stream of tokens. The result maps line numbers in multi-line statements to the first line number of their statement. This is the only place the map is computed: `PythonParser._raw_parse` uses it for parsing and reporting, and the sys.monitoring core uses `multiline_map_from_text` to get the map without paying for a full parse during measurement. r)tokenNEWLINErangestriptokenizeCOMMENT) tokens multiline_map first_linetoktypettextslineno_elinenolinenos T/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/coverage/parser.pymultiline_map_from_tokensr's-/MJ9? %5 !lwA emm #g3$J! <7F,6M&)7J ;;=W(8(88$  % c*tt|S)zCompute just the multiline map for `text`, without a full parse. Can raise tokenize.TokenError, IndentationError, or SyntaxError if the text isn't parsable as Python. )r'r)texts r&multiline_map_from_textr+<s %_T%: ;;r(ceZdZdZ d ddZddZddZddZddZddZ dd Z dd Z dd Z dd Z dd ZddZddZddZddZy) PythonParserzParse code to find executable lines, excluded lines, etc. This information is all based on static analysis: no code execution is involved. Nc|s |sJd|xsd|_|||_nddlm} ||j|_||_d|_t|_ t|_ t|_ t|_ t|_ d|_i|_d|_d|_i|_i|_y#t$r!}t d|jd||d}~wwxYw) z Source can be provided as `text`, the text itself, or `filename`, from which the text will be read. Excluded lines are those that match `exclude`, a regex string. z*PythonParser needs either text or filenamezNr)get_python_sourcezNo source for code: 'z': F)filenamer*coverage.pythonr/OSErrorr exclude _ast_rootset statementsexcludedraw_statements raw_excludedraw_docstrings show_tokensr _all_arcs_missing_arc_fragments_with_jump_fixers_first_line_cache)selfr*r0r3r/errs r&__init__zPythonParser.__init__NsxM!MM ,H  !DI 9 Y-dmm<  *. ),'*e -0E+.%-0E!68,0<@#:<9;U Y!6t}}oSNOUXX YsC C- C((C-c t}d}d}tj|jtjD]}|j \}}|jj d||z}|jj d||z} |jfdt|dz| dzD|}|}|S)zFind the lines matching a regex. Returns a set of line numbers, the lines that contain a match for `regex`. The entire line needn't match, just a part of it. Handles multiline regex patterns. r)flags c3VK|] }jj||"ywN)rget).0ir@s r& z.PythonParser.lines_matching..s)12""&&q!,s&)r) r5refinditerr* MULTILINEspancountupdater) r@regexmatches last_startlast_start_linematchstartend start_lineend_lines ` r&lines_matchingzPythonParser.lines_matchings!$ [[ F )EJE3(499??4U+SSJ&z3)OOH NN6;JNHWXL6Y J(O )r(c  |jr:|j|j|_t|j|_d}d}d}d}d}d}|j Jt t|j }t||_ |D]x\}} \} } \} } } |jrBttjj||ddt| | fdd| dd| |t j"k(r|d z }n|t j$k(r|d z}n|t j&k(rj| d k(rQ|dk(rL|jj)t+|| d z}|sK|rI|jj-| |}d}n)| d vr|d z }n| d vr|d z}n|t j.k(rd}| j1s4|tj2k7sId}|rO| }|r||krd}|s^|jj-| {|sJt5|j |j6 }|j8j;|j=|j?|j|_|j@JtC|j@D]}tE|tFjHtFjJtFjLtFjNfr|jPr|jPd}tE|tFjRrtE|jTtFjVrntE|jTjTtXrJ|jZj;t+|j\t_t`|jbd ztE|tFjHtFjJtFjLfrted|jfD|j\}|jj)t+||j\d zr@|jj;t+|t_t`|jbd ztE|tFjhstk|st+|jPdj\t_t`|jPdjbd z}|j8t|z}|sv||jks|jj;t+|jlj\|jljbd zy)zwParse the source to find the interesting facts about its lines. A handful of attributes are updated. rFTNz>10 z>520r:z([{z)]})r*r0c34K|]}|jywrGr%)rIds r&rKz*PythonParser._raw_parse.. s!Hq!((!Hs)default)7r3r\r9r5r7r*listrr'rr;printrtok_namerHrrINDENTDEDENTOP intersectionraddrrrr r0r8rRfind_statements first_linesr4walk_statement_nodes isinstanceastClassDef FunctionDefAsyncFunctionDefModulebodyExprvalueConstantstrr:r%r int end_linenomindecorator_list match_case_case_is_irrefutablepattern)r@indentexclude_indent excludingremptynestingrr r!r"r#r$ltextshould_exclude byte_parsernodefirst body_linesbody_statementss r& _raw_parsezPythonParser._raw_parses6 << $ 3 3DLL AD  1 12DM  yy$$$odii016v>AG- 3 =GULWa,7A!))--gw?!7G"45 %,,&! ELL(! EHH$C++22!%,,S%:J:J0Ka0OP $s@T@T UV !HD4G4G!HRVR]R]^ ==--eJ a.PQMM((z4T__;UXY;Y)Z[ $/4H4N"499Q<#6#6S$))B-BZBZ8[^_8_` "&"5"5J"G"$--'GMM((t||/B/BDLLD[D[^_D_)`a9 br(c|jj|}|P|dkr |jj| |  }n|jj||}||j|<|S)zAReturn the first line number of the statement including `lineno`.r)r?rHr)r@r%rs r&rzPythonParser.first_linesp&&**62 =z++//&AA**..vv>-2D " "6 * r(cJ|Dchc]}|j|c}Scc}w)zMap the line numbers in `linenos` to the correct first line of the statement. Returns a set of the first lines. )r)r@linenosr%s r&rozPythonParser.first_lines#s!7>>F'>>>s c$|j|S)z)Implement `FileReporter.translate_lines`.)ro)r@liness r&translate_lineszPythonParser.translate_lines,s&&r(c|j|Dchc]'\}}|j||j|f)c}}Scc}}w)z(Implement `FileReporter.translate_arcs`.)fix_with_jumpsr)r@arcsabs r&translate_arcszPythonParser.translate_arcs0s=GKGZGZ[_G`aVa#T__Q%78aaas,Ac tj|j|_|j |j|jz}|j |z }|j#||z |_y#t j ttf$r_}t|dr |j}n|jdd}td|jd|jdd|z|d}~wwxYw)zParse source text to find executable lines, excluded lines, etc. Sets the .excluded and .statements attributes, normalized to the first line of multi-line statements. r%rrzCouldn't parse 'z' as Python source: z at line N)rrparser*r4rr TokenErrorIndentationError SyntaxErrorhasattrr%argsrr0r7r:r8ror6)r@rAr%ignorestartss r& parse_sourcezPythonParser.parse_source4s  YYtyy1DN OO !4!44$$v-**62V;##%5{C sH%!Q"4==/1EFXXa[O9VH56   s4A88C5AC00C5cn|j|j|jJ|jS)zGet information about the arcs available in the code. Returns a set of line number pairs. Line numbers have been normalized to the first line of multi-line statements. )r< _analyze_astr@s r&rzPythonParser.arcsLs4 >> !    ~~)))~~r(c|jJt|j|j|j|j}|j |j }|j|_|jr|j|}t|_ |D]J\}}|j|}|j|}||k7s.|jj||fL|j|_d|_y)zkRun the AstArcAnalyzer and save its results. `_all_arcs` is the set of arcs in the code. N)r4AstArcAnalyzerr0r8ranalyzerwith_jump_fixersr>rr5r<rrmmissing_arc_fragmentsr=)r@aaarl1l2fl1fl2s r&rzPythonParser._analyze_astXs ~~)))T]]DNND1 should be replaced with 3->4, and 1->4 should be removed. For this code, the fixers dict is {(3, 1): (3, 4), (1, 4): None}. The keys are arcs to adjust. The values are the arcs to use instead, or None if the arc should be removed. )r5r>rHrm)r@rfixedarcnew_arcs r&rzPythonParser.fix_with_jumpsssK& #C,,00c:G" '" # r(ctjt}|jD]L\}}|dkDsJd|d|j||j vr1||j vr@||xxdz cc<N|S)zYGet a count of exits from that each line. Excluded lines are excluded. rzl1=z should be greater than zero in r) collections defaultdictr|rr0r7)r@ exit_countsrrs r&rzPythonParser.exit_countss +6*A*A#*F iik !FB6 RcbU"B4==/R R6T]]"T]]" Oq O !r(cB| |dkrd}nd}|j|}|S)z=Apply some defaulting and formatting to an arc's description.rzjump to the function exitzjump to line {lineno}rb)format)r@ action_msgrYs r&_finish_action_msgzPythonParser._finish_action_msgs2  Qw8 4 &&c&2 r(cX|j|j|jJ|jj||fdg}g}|D]J\}}|j||}d|d|}||d|j |z }|j |Ldj |S)z5Provide an English sentence describing a missing arc.NNzline z didn't z because rbz or )r=rrHrrappendjoin)r@rXrYfragment_pairsmsgsmissing_cause_msgrmsgs r&missing_arc_descriptionz$PythonParser.missing_arc_descriptions  & & .    ..: ::4488% ~V-;  ) z00SAJ% 5C ,#4#;#;5#;#I"JKK KK   {{4  r(c|jJ|jj||fdg}|j|dd|}|S)z2Provide an English description of an arc's effect.rrr)r=rHr)r@rXrYrrs r&arc_descriptionzPythonParser.arc_descriptionsT**6664488% ~V,,^A->q-A3G r()NNN)r* str | Noner0rr3rreturnNone)rSr{r set[TLineNo]rr)r%rrr)rIterable[TLineNo]rr)rrrr)rzIterable[TArc]r set[TArc])rr)rzdict[TLineNo, int])rrrYrrr{)rXrrYrrr{)__name__ __module__ __qualname____doc__rBr\rrrorrrrrrrrrrr(r&r-r-Fs #" ?<?<?< ?<  ?A block on the block stack representing a function definition.c ||_||_yrGrXname)r@rXrs r&rBzFunctionBlock.__init__:s  r(c|D]9}||j|j |jd|j;y)Nzexcept from function Tr%rXrrrs r&rz!FunctionBlock.process_raise_exits@C C    ' }5   r(c|D]9}||j|j |jd|j;y)Nzreturn from function Trrs r&rz"FunctionBlock.process_return_exitsJrr(N)rXrrr{rrr)rrrrrBrrrr(r&rr7sH r(rc eZdZdZddZddZy)TryBlockz6A block on the block stack representing a `try` block.c ||_||_yrG) handler_start final_start)r@r r s r&rBzTryBlock.__init__Xs*&r(cz|j/|D]*}||j|j|j,yr)r r%rrs r&rzTryBlock.process_raise_exits^s<    ) C D$6$6 B Cr(N)r TLineNo | Noner r rrr)rrrrrBrrr(r&rrUs@' r(rc#K|g}|rT|j}|tj|D]$}t|ts|j |&|rSyyw)aYield `root` and its descendant statement-level nodes. Like ast.walk, but skips expression subtrees entirely, since statements (including def and class) can never appear inside them. This visits a small fraction of the nodes ast.walk does, which matters when scanning many files during reporting. ExceptHandler and match_case nodes are also yielded; callers only interested in particular node types must check for them. N)poprriter_child_nodesrq_STMT_CONTAINERSr)roottodorchilds r&rprpnsX 6D xxz ))$/ #E%!12 E" # sAAAAc|jy|j}t|tjr*|j d}t|tjr*t|tj r?|j3|j}t|tj r |j3t|tj xr|jduS)zWill this `case` clause always match, like `case _:` does? An irrefutable case has a wildcard or bare-capture pattern and no guard, so anything reaching it will match. These are the `match` equivalent of an `else` clause. NFre)guardrrqrrMatchOrpatternsMatchAs)casers r&rrs zzllG Wckk *""2& Wckk * Wckk *w/J// Wckk *w/J gs{{ + G40GGr(c|xtjdx\dt|jfSxtjdx)\|j dvrdt |j fSyxtjdxE\t|jtjrt|j\}}|| fSytjdxz\|jDcgc] }t|}}td|D}|rAt|jtj rt"nt}d|d|DfSyycc}w)zIs this a compile-time constant test expression? We don't try to mimic all of CPython's optimizations. We just have to handle the kinds of constant expressions people might actually use. rT)TrueFalser __debug__c3&K|] \}}| ywrGr)rIis_constr#s r&rKz(is_constant_test_expr..s?;8Qh?c3&K|] \}}| ywrGr)rIr#vs r&rKz(is_constant_test_expr..s3da3r )FF)rrrzrryNameidevalUnaryOprqopNotis_constant_test_exproperandBoolOpvaluesallOrany)r is_constantvalr"retsr's r&r)r)s%  S\\^djj)) ) SXXZww@@T$'']** S[[]$''377+#8#F S"G++ ZZ\6:kkB)!,BDB?$??K&tww7SSR3d3333    Cs,Ec|eZdZdZ d#dZd$dZd%dZd&dZd'dZd(dZ d) d*d Z d+d Z d,d Z d-d Z d.d Ze Zd/dZe Ze Zd0dZd1dZedZd2dZ d) d3dZd4dZd4dZd4dZd4dZd5dZd6dZeZd7dZ d8dZ!e!Z"eZ#eZ$d9dZ%d:dZ&d;dZ'dd!Z+d?d"Z,e,Z-y)@raAnalyze source text with an AST to find executable code paths. The .analyze() method does the work, and populates these attributes: `arcs`: a set of (from, to) pairs of the the arcs possible in the code. `missing_arc_fragments`: a dict mapping (from, to) arcs to lists of message fragments explaining why the arc is missing from execution:: { (start, end): [(missing_cause_msg, action_msg), ...], } For an arc starting from line 17, they should be usable to form complete sentences like: "Line 17 didn't {action_msg} because {missing_cause_msg}". NOTE: Starting in July 2024, I've been whittling this down to only report arc that are part of true branches. It's not clear how far this work will go. c||_||_|Dchc]}|j||c}|_||_t t tjdd}|r[td|jtd|jttj|jddt|_ tjt |_g|_t|_t|_t|_t|_t t tjdd|_ycc}w) NCOVERAGE_AST_DUMP0z Statements: zMultiline map: T)include_attributesrCOVERAGE_TRACK_ARCS)r0 root_noderHr6 multilinerr|osgetenvrgrrdumpr5rrrrfr block_stackcurrent_with_startsall_with_starts with_entries with_exitsdebug)r@r0r:r6r;r%dump_asts r&rBzAstArcAnalyzer.__init__s ! "GQRV9==8R"BII&93?@A  L 12 3 ODNN#34 5 #((4>>d1M N"u 4?4K4KD4Q"(* 25 -0U'*u%(U#bii(=sCDE 7SsEc`t|jD]}t|tjtj fr|j |?t|tjr|j|kt|tjs|j|y)zFExamine the AST tree from `self.root_node` to determine possible arcs.N) rpr:rqrrrtru_code_object__FunctionDefrs_code_object__ClassDefrv_code_object__Moduler@rs r&rzAstArcAnalyzer.analyzesy(8 0D$#2F2F GH..t4D#,,/++D1D#**-))$/  0r(c jDchc]#}|djvr|jvr|%}}i jD]N}|Dchc]}|d|k(s |d}}|s!t|dk(s Jd|d||j |<Pd fd }i}j D]\}}| vs |||f|||f< j D]\}}||fj vsd|||f<|Scc}wcc}w)a}Get a dict with data for fixing jumps out of with statements. Returns a dict. The keys are arcs that need adjusting: arcs jumping back to the start of a with-statement at the end of its body, and arcs from the start of a with-statement to the next statement. The values are the arcs to use instead, or None if the arc should be removed. rrzExpected one arc, got z with start = cr|}||fjvr |vr||}}||fjvr|vr|SrG)rC)rXnxtnextsr@s r& final_nextz3AstArcAnalyzer.with_jump_fixers..final_next sN,C#,$//1cUl %*s#,$//1cUlJr(N)rXrrr)rrArBlenrrCitems) r@r with_nextsrX start_nextsrOfixersrYrMrNs ` @r&rzAstArcAnalyzer.with_jump_fixerssTyy 1v---#T=N=N2N   )+)) -E-7Kc3q6U?3q6KKK{#q( `,B;-V[U_*` `(&??,E%L  - +-// @JC ~(+Z->'?U|$  @ ++- ,JE3 u~T__4'+s|$ , M Ls(C= DDc|j|}|jrL|j|j}|D]+}|j|j| |j d-y|j|| y)Nzexit the module) line_for_noderw process_bodyrr%rr@rrXrrs r&rIz#AstArcAnalyzer._code_object__Module*sm""4( 99%%dii0E O SZZ% i[ ! 8   4=D;;D~~!!$--r(cl|jr|jdj}|S|j}|S)zSCompute first line number for things that can be decorated (classes and functions).r)rr%)r@rr%s r&_line_decoratedzAstArcAnalyzer._line_decoratedns8   ((+22F [[F r(c8|j|jSrG)rVryrJs r& _line__AssignzAstArcAnalyzer._line__Assignvs!!$**--r(c|jrA|jd|jdjS|jdjS|jSNr)keysr%r,rJs r& _line__DictzAstArcAnalyzer._line__Dict{sK 99yy|'yy|***{{1~,,,;; r(cn|jr|j|jdS|jSrk)eltsrVr%rJs r& _line__ListzAstArcAnalyzer._line__Lists, 99%%diil3 3;; r(cy)NrrrJs r& _line__ModulezAstArcAnalyzer._line__Modulesr() AnnAssignAssignAssert AugAssignDeleterxGlobalImport ImportFromNonlocalPassc|jj}t|d|d}| ||}|Stjr||j vrt d|t|j|h}|S)aFind the set of arc starts that exit this node. Return a set of ArcStarts, exits from this node to the next. Because a node represents an entire sub-tree (including its children), the exits from a node can be arbitrarily complex:: if something(1): if other(2): doit(3) else: doit(5) There are three exits from line 1: they start at lines 1, 3 and 5. There are two exits from line 2: lines 3 and 5. _handle__Nz*** Unhandled: ) rarrbr TESTING OK_TO_DEFAULT RuntimeErrorrrV)r@rrcrd arc_startss r& node_exitszAstArcAnalyzer.node_exitss"NN++ =D  { # >    J {{D$6$66&'?@@#4#5#5d#;<=Jr(c|| t}n|h}n|J|D]a}|j|}||jvr#|D])}|j|j||j +|j |}c|S)aProcess the body of a compound statement. `body` is the body node to process. `from_start` is a single `ArcStart` that starts an arc into this body. `prev_starts` is a set of ArcStarts that can all be the start of arcs into this body. Only one of `from_start` and `prev_starts` should be given. Records arcs within the body by calling `self.add_arc`. Returns a set of ArcStarts, the exits from this body. )r5rVr6rr%rr)r@rw from_start prev_starts body_noder% prev_starts r&rWzAstArcAnalyzer.process_bodys(  !!e )l % %% 5I'' 2FT__,) J  Z.. 8H8HI J//)4K  5r(cj|jD] }|j||js yy)z0Add arcs due to jumps from `exits` being breaks.N)r^rrr@rblocks r&rz"AstArcAnalyzer.process_break_exits1((* E(( = r(cj|jD] }|j||js yy)z3Add arcs due to jumps from `exits` being continues.N)r^rrrs r&rz%AstArcAnalyzer.process_continue_exitss1((* E++E4<<@ r(cj|jD] }|j||js yy)z0Add arcs due to jumps from `exits` being raises.N)r^rrrs r&rz"AstArcAnalyzer.process_raise_exitsrr(cj|jD] }|j||js yy)z1Add arcs due to jumps from `exits` being returns.N)r^rrrs r&rz#AstArcAnalyzer.process_return_exitss1((* E))%> r(cv|j|}t|d}|j|htS)Nz*the break on line {lineno} wasn't executedr)rVrrr5)r@rhere break_starts r&_handle__BreakzAstArcAnalyzer._handle__Breaks6!!$'t+WX    +/u r(c||j}|j}|j}|rd}|D].}|j|}|||k7r|j|||}0|J|j|||}|js.Jd|jd|j d|j|Jt |hS)zBAdd arcs for things that can be decorated (classes and functions).NzOops: node.body = z in @)r%rrVrrwr0r)r@r main_linelastdecsdec_node dec_starts r&_handle_decoratedz AstArcAnalyzer._handle_decorateds![[ #{{"" D  ! ..x8 # T(9LLy1   ! # ## LLy )D 99 V 3tyynDq V V9r(cv|j|}t|d}|j|htS)Nz-the continue on line {lineno} wasn't executedr)rVrrr5)r@rrcontinue_starts r&_handle__Continuez AstArcAnalyzer._handle__Continue9s7!!$'!$.]^ ##^$45u r(cB|j|j}|jjt |t |d}|j |j|}|D])}|j|j||j+|jj}t|tsJ|j}t |d}|jr$|j |j|}||z}|S|j||S)NrXz'the loop on line {lineno} never startedrrz)the loop on line {lineno} didn't complete)rViterr?rrrrWrwrr%rrrqrorelserm)r@rrXrrrmy_block else_exitss r& _handle__ForzAstArcAnalyzer._handle__For?s""499-   67e+TU !!$)) !C 7C LLUCII 6 7##'')(I...$$e+VW ;;**4;;:*NJ Z E  IIj ! r(cD|j|j}t|j\}}t}|r|r-t |d}||j |j |z}|r|s-t |d}||j |j|z}|S)N-the condition on line {lineno} was never truerr.the condition on line {lineno} was always true)rVtestr)r5rrWrwr)r@rrX constant_testr1rrs r& _handle__IfzAstArcAnalyzer._handle__IfXs""499-2499= s!%/^_J T&&tyyZ&H HEC!%/_`J T&&t{{z&J JE r(cn|j|}|}t}|jD]_}|j|j}|j ||dt |d}||j |j|z}|}at}|s|jt d|S)Nz+the pattern on line {lineno} always matchedz*the pattern on line {lineno} never matchedrr) rVr5casesrrrrWrwrrm) r@rrXrUrr case_startr had_wildcards r&_handle__MatchzAstArcAnalyzer._handle__Matchds""4( JJ $D++DLL9J LLZ1^ _!BJ T&&tyyZ&H HE#J $,D1  II+XY  r(cv|j|}t|d}|j|htS)Nz*the raise on line {lineno} wasn't executedr)rVrrr5)r@rr raise_starts r&_handle__RaisezAstArcAnalyzer._handle__Raise{s6!!$'t+WX    +/u r(cv|j|}t|d}|j|htS)Nz+the return on line {lineno} wasn't executedr)rVrrr5)r@rr return_starts r&_handle__ReturnzAstArcAnalyzer._handle__Returns6!!$',YZ  !!<.1u r(c|jr|j|jd}nd}|jr|j|jd}nd}||Jt||}|jj ||j|}|j |jt|}|jrd|_ n|jjt}|jrQ|jD]B}|j|}d} t|| } ||j |j| z}D|jr|j |j|}||z}|jr=|jj|} |j |j| } |r| }|S)Nrrz3the exception caught by line {lineno} didn't happenr)r) handlersrV finalbodyrr?rrWrwrr rr5r) r@rr r  try_blockrXr handler_exits handler_node from_causer final_from final_exitss r& _handle__TryzAstArcAnalyzer._handle__Trys == ..t}}Q/?@M M >>,,T^^A->?KK(K,CCC]K8   *""4(!!$))!H >>&*I #    "'*u == $  ] $ 2 2< @ R %m:F !2!2<3D3DQ[!2!\\  ] ;;%%dkku%EE  >>    "J++DNN +SK$ r(c|j|jx}}t|j\}}|jj t |t |d}|j|j|}|D])}|j|j||j+t}|jj} t| t sJ|j| j t |d}|j"r$|j|j"|} || z}|S|s|j%||S)Nrrrrr)rVrr)r?rrrrWrwrr%rr5rrqrRrrrm) r@rrXto_toprr#rrrrrs r&_handle__WhilezAstArcAnalyzer._handle__Whiles%++DII660; q   78e+Z[ !!$)) !C 8C LLVSYY 7 8##'')(I... X))*e+[\ ;;**4;;:*NJ Z E  ! *% r(ctjjr3|jDcgc]}|j |j }}n|j |g}|D]8}|j j||jj|:|j|jt|d}|d}|j j|t|h}|rL|D]E}|j|j||jj|j|fG|}|Scc}w)Nrer)r PYBEHAVIORexit_with_through_ctxmgrrQrV context_exprr@rmrArWrwrremoverr%rC)r@ritemrrXr with_exitrs r& _handle__WithzAstArcAnalyzer._handle__Withs >> 2 2HL Sd(():):;SFS((./F ,E  $ $ ( ( /  $ $U + ,!!$))8L!Mr    ''.e_%  9 SZZ/##SZZ$78 9E %Ts"E) r0r{r:ast.ASTr6rr;dict[TLineNo, TLineNo]rrr)rzdict[TArc, TArc | None])r ast.Modulerr)rz&ast.FunctionDef | ast.AsyncFunctionDefrr)rz ast.ClassDefrrrr)rzIterable[Block])rrrr)rast.FunctionDefrr)rz ast.Assignrr)rzast.Dictrr)rzast.Listrr)rrrr)rrrr)rwzSequence[ast.AST]rzArcStart | Nonerzset[ArcStart] | Nonerr)rrrr)rz ast.Breakrr)rrrr)rz ast.Continuerr)rzast.Forrr)rzast.Ifrr)rz ast.Matchrr)rz ast.Raiserr)rz ast.Returnrr)rzast.Tryrr)rz ast.Whilerr)rzast.Withrr).rrrrrBrrrIrGrHrr^rVrgri_line__ClassDefrm_line__FunctionDef_line__AsyncFunctionDefrprr frozensetrrrWrrrrrr_handle__ClassDefrr_handle__AsyncFor_handle__FunctionDef_handle__AsyncFunctionDefrrrrr_handle__TryStarrr_handle__AsyncWithrr(r&rrs($F$F$F! $F * $F  $FL0/l(U)-!% ]]]& ]  ]  ]$*...&O )-  M "N'+,0 %%$%* %  %^   "  0* (%, 1 .5n$,,'r(r)rzIterable[TToken]rr)r*r{rr)rrrzIterable[ast.AST])rzast.match_caserr)rrrztuple[bool, bool]):r __future__rrrrr<rMrrcollections.abcrrr dataclassesrtypingrr coverager coverage.bytecoder coverage.debugr coverage.exceptionsr r coverage.miscrrcoverage.phystokensrrcoverage.typesrrr'r+r-rrdictrftupler{ TArcFragmentsrrrrstmt excepthandlerrrrprr)rrr(r&rs$#  88!!(&337(B:<||H  $d#$D  0T4cDj#*&< =>>? 8&E< u ,HHc//@#*H$4''r(