wgLddlZddlZddlZddlZddlmZmZmZm Z m Z m Z m Z m Z ddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"ddlm#Z#m$Z$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+dd l,m-Z-dd l.m/Z/dd l0m1Z1dd lm2Z2dd l3m4Z5ddl6Z7ddl8Z8ddl9Z dZ:dZ;dZ<Gdde=Z>dZ?Gdde=Z@ d*dZAdZBdZCdZDdZEdZFdZGdZHdZIdZJd ZKe)d!ZL d+d"ZMd#ZNd$ZOd%ZPe jd&Gd'd(e jZSd)ZTy),N)typestypingerrorsirrewritesconfigir_utilscgutils)internal_prange) next_labeladd_offset_to_labels replace_vars remove_dels rename_labelsfind_topo_ordermerge_adjacent_blocksGuardExceptionrequireguardget_definition find_callnamefind_build_sequenceget_np_ufunc_typget_ir_of_code simplify_CFGcanonicalize_array_mathdead_code_elimination)compute_cfg_from_blockscompute_use_defscompute_live_variables)impl_ret_untracked) intrinsic) signatureListIterInstance)range_impl_map) make_array)postproc)empty_inferredTc|jjD]m}|jtjD]I}t |j tjs(d}tj||joy)z8Checks the IR of a callee is supported for inlining z-The use of yield in a closure is unsupported.locN) blocksvalues find_instsrAssign isinstancevalueYieldrUnsupportedErrorr,)func_irblkstmtmsgs b/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/numba/core/inline_closurecall.pycallee_ir_validatorr:4sn~~$$&ANN299- AD$**bhh/E--ctxx@@ AAc|d|}|jddjdd}|jddjdd}|S)aCreates a name for an inlined variable based on the function name and the variable name. It does this "safely" to avoid the use of characters that are illegal in python variable names as there are occasions when function generation needs valid python name tokens..<_>$_v)replace) function_namevar_name inlined_namenew_names r9_created_inlined_var_namerH>sY $_AhZ0L##C-55c3?HS)11#tz+InlineClosureCallPass.run..s CFr;)keyreverseENDN)+r( PostProcessorr5runlistr-items_make_debug_printpop enumeratebodyr1rr0r2Exproprrrfunc_inline_reduction_inline_closure_inline_stencilenable_inline_arraycallrr _debug_dumploopskeyslensortedappend_inline_arraycallrNrM comprehensionrP_fix_nested_array dead_nodesrrr)rQppmodified work_list debug_print_labelblockiinstrexpr call_namefunc_defcfgrok sized_loopsvisitedsdeads r9r`zInlineClosureCallPass.runXs # #DLL 1 t ,,2245 '(?@ G%MMOMFE%ejj1 ,5eRYY/ ;;D!$0TWW5F$)-t$L #()-$4!!7!7!*E1dIG'+H! !5!5!*E1h@'+H! !5!5!& 8='+H) ,0 #%dll&9&9:)$,,*=*=>C 0 1  IIKEC( .LL''- . "$,, /"/ 0C0C"DDLL  DLL''(E;Js!M8c t|jj t|dk(xs|dk(t|jdvr t dt |j|jdd d}t|j|jjjj||||ty) N)reducebuiltins)r _functools)z^invalid reduce call, two arguments are required (optional initial value can also be specified)rc\t|}||}n t|}|D] }|||} |SrL)iternext)fAvitras r9 reduce_funcz.reduce_funcs=aB}H aG Hr;rzcallee_validatorTrL) rrM reductionrqargs TypeErrorcheck_reduce_funcr5inline_closure_callfunc_idri __globals__r:)rQrzr}r~rrrs r9rjz'InlineClosureCallPass._inline_reductions D))3334 33655 7 tyy> ';< < $,, ! 5   LL$,,..33?? 1kY0 r;cddlm}|j}|j}t |t j rw|jdk(rht |j|rR|jr*|xj|jjz c_y|jj|_yt|dk(xs|dk(t||jv|jj|t|jdk(s tdtt |j"|jd}tt |t j$xr|j&d k(t)|j"j*j,j.|j0}t3|j} d | vr#t|j4| } | s td d | vr#t|j6| } | s td ||d| } |j| _t j d| |j8} | g|j"j:|j<| |_y)Nr) StencilFuncstencilT)rznumba.stencils.stencil)rnumbarXz5As a minimum Stencil requires a kernel as an argument make_function neighborhoodzXstencil neighborhood option should be a tuple with constant structure such as ((-w, w),) index_offsetszYstencil index_offsets option should be a tuple with constant structure such as (offset, )constant)numba.stencils.stencilrtargetr2r1rGlobalnamekwsrrOrsrqr ValueErrorrrr5rgrhrrrircodedict_fix_stencil_neighborhood_fix_stencil_index_offsetsr, _definitions) rQrrrrlhsr stencil_def kernel_iroptionsfixedsf sf_globals r9rlz%InlineClosureCallPass._inline_stencils6ll{{ x + *8>>;7xxHNN...$>>-- BB211 3D4445   ''-499~"89 9NDLL$))A,G  ;02/1 3"4<<#7#7#<#<#H#H#.#3#35 txx. W $$88'BE B g %$997CE BJ 8IIiTXX6 /8k !!#((+ r;c@t|j|d}tt|dg}|jD]Q}t|j|}tt|d|j t |jSt ||d<y)z Extract the two-level tuple representing the stencil neighborhood from the program IR to provide a tuple to StencilFunc. rrbT)rr5rhasattrrbrstuple)rQrdims_build_tupleres window_varwin_build_tuples r9rz/InlineClosureCallPass._fix_stencil_neighborhoods *$,,8OP('23*00 5J,T\\:FO GOW5 6 JJu_223 4 5#(*r;ct|j|d}tt|dt |j |d<y)z Extract the tuple representing the stencil index offsets from the program IR to provide to StencilFunc. rrbT)rr5rrrrb)rQr offset_tuples r9rz0InlineClosureCallPass._fix_stencil_index_offsetss@ &dllGO4LM  g./#(););#< r;c tt|tjxr|jdk(t |j |j jjj||||ty)NrrT) rr1rrgrhrr5rrirr:)rQrzr}r~rs r9rkz%InlineClosureCallPass._inline_closure sa 8RWW-/ . 0DLL LL0055AA!1h)-@ Br;N) __name__ __module__ __qualname____doc__rRr`rjrlrrrkrYr;r9rJrJLs4;=EIV:0d r;rJc tt||}| tdt|tj tj frZt|jtjjjs td|jj}n#t|dst|ds tdt|dr |jn |j}|j dk(s t#d|S)zsChecks the function at func_var in func_ir to make sure it's amenable for inlining. Returns the function itselfzMReduce function cannot be found for njit analysiszInvalid reduction functionr__code__rz*Reduction function should take 2 arguments)rrrr1rFreeVarrr2rcoreregistry CPUDispatcherpy_funcrrr co_argcountr)r5func_varrf_codes r9rrs:K&' '+ BII67+++**--;;=9: :!''// k6*j1566f-''     "DEE r;cHeZdZdZdddddeddfdZ ddZddZd dZdZ y) InlineWorkera= A worker class for inlining, this is a more advanced version of `inline_closure_call` in that it permits inlining from function type, Numba IR and code object. It also, runs the entire untyped compiler pipeline on the inlinee to ensure that it is transformed as though it were compiled directly. Nc @d} ddlm} ||||f} | D cgc]} | du} } t| r0t| s%| |d| |d| |d| |dnt| r | |d | j|_||_||_||_||_ ||_ ||_ td |_ ||f}|D cgc]} | du}} t|rt|sd }t||zt| |_||_||_ycc} wcc} w) a1 Instantiate a new InlineWorker, all arguments are optional though some must be supplied together for certain use cases. The methods will refuse to run if the object isn't configured in the manner needed. Args are the same as those in a numba.core.Compiler.state, except the validator which is a function taking Numba IR and validating it for use when inlining (this is optional and really to just provide better error messages about things which the inliner cannot handle like yield in closure). c<|tdj|y)Nz{} must not be None)rformat)argrs r9checkz$InlineWorker.__init__..checkHs#{ 5 < ?A!4-?? ~ s>': )[ ) &( # (J ' % !  )[ )"4"L"L""    ",^<#+/0aT 0 0 | S%6(CC$J' '585F1F. ";@,1s D DcN d}||}|j|j|||}|j} |j|} | j} |j} t t jjt |jj} t| | dz} t| } | |_t| j}t | j} t jj| |jdt|t!| }|jd|t#|dk(sJ|d}i}t%|j&j(j+D]}|j,|vst/|j0j2|j,}| j5||j6}|j5||j6|||j,<|jd|t9| ||jd t||j0j:}t=| ||j|j6|}|j>r+| tAd |jC|||j} |jd t|tE| |g}tGjH| |j6}|j|dzd|_tK}||j|<|jM||f|jd||_|jjMtGjN|| j6tQ| }tS| | jT|| jTj,|jVvrW| |jV| jTj,vr2|jV| jTj,jY| |D]<}| |}| |_t[||||j|<|jM||f>|jd t||| ||fS) a Inlines the callee_ir in the caller_ir at statement index i of block `block`, callee_freevars are the free variables for the callee_ir. If the callee_ir is derived from a function `func` then this is `func.__code__.co_freevars`. If `arg_typs` is given and the InlineWorker instance was initialized with a typemap and calltypes then they will be appropriately updated based on the arg_typs. c|j}i|_|jjD]6\}}tj|j|}||j|<8|SrL)copyr-rbdeepcopy)the_ir kernel_copy block_labelr} new_blocks r9copy_irz'InlineWorker.inline_ir..copy_ir{se ++-K!#K &,mm&9&9&; <" U MM&-- *DE 2; "";/ < r;NrX After relabelcallee_scopes = rr+ var_dict = After local var renamez%arg_typs should have a value not NoneAfter arguments rename: After merge in).rscoperfr2r-maxr _the_max_labelrrpr rminupdater{rn_get_all_scopesrqr localvars_conr.rrHr unique_nameredefiner,rri_get_callee_argsrrupdate_type_and_call_maps_replace_args_withrBlockr rsJumpr_replace_returnsrrremove_add_definitions)rQ caller_irr}r~ callee_ircallee_freevarsarg_typsrcallee_ir_originalrr call_expr callee_blocks max_label min_label callee_scopes callee_scopevar_dictvarrFnew_var callee_funcr new_blocksr new_label topo_orderlabels r9 inline_irzInlineWorker.inline_irps I&  >> % NN9 %%Y/  1 KK !((   # # ( ( *    %%' ( -]IMJ $]3 (  **,-  **,- &&y1 )I( 6  +];M"a'('$Q' //44;;=> -CHH/8%%11388 =  ..377.C %%l%@%," - 1]H- 12I '',,  ; 1 8I8I )+  1 1 GHH  * *9h ?%,,M 34I=$/ HHUEII. AEF+ L &/ #9i01ZZ^  "'')UYY78%]3  i@ LL  !7!7 7!7!7 8I8I!JJ  " "5<<#4#4 5 < j@fz|_!|jE|} | jG| jI||jS)a& Run the compiler frontend's untyped passes over the given Python function, and return the function's canonical Numba IR. Disable SSA transformation by default, since the call site won't be in SSA form and self.inline_ir depends on this being the case. r) StateDict_CompileStatus)ExtractByteCode)bytecode)ParforDiagnosticsNF)%rr*r+numba.core.untyped_passesr, numba.corer-numba.parfors.parforr.r5rrrrr enable_ssaFunctionIdentity from_functionrrrtype_annotationstatus return_typeparfor_diagnosticsmetadatarun_passrqbcpysig parametersrpyobjectrrfinalizer`) rQrir2r*r+r,r-r.statepms r9r$zInlineWorker.run_untyped_passess% B=':  ....{{ jj !+  11??E   $%e,  #4#6 ""5)))//::;u~~>OO  $ $U +  u }}r;c6ddlm}ddlm}|js d}t |ddlm}tj|j|_ tjjj||||}tj|j|_ |j!|j"|j$||d\}}} } |j'|}tj|j|_ t)||| |j"|D cgc]} | j+ds| } } | D]} |j-| |j.j1||j2j1| ycc} w)z_ Updates the type and call maps based on calling callee_ir with arguments from arg_typsr)reconstruct_ssa)PreLowerStripPhisz_InlineWorker instance not configured correctly, typemap or calltypes missing in initialization. typed_passesNarg.)numba.core.ssarCnumba.core.typed_passesrDrrr0rFr build_definitionsr-rrranalysisdead_branch_prunetype_inference_stagerr_strip_phi_nodesr startswithrdrrr)rQrrrCrDr8rF f_typemap_f_return_type f_calltypesr?vname arg_namesrs r9rz&InlineWorker.update_type_and_call_maps sY 3=55:CS/ !+!)!;!;I|dt5|| |)D]}| j|||fS#t|$r|!j{||||d \}"}#}$}%YZwxYwcc}&w)aInline the body of `callee` at its callsite (`i`-th instruction of `block`) `func_ir` is the func_ir object of the caller function and `glbls` is its global variable environment (func_ir.func_id.func.__globals__). `block` is the IR block of the callsite and `i` is the index of the callsite's node. `callee` is either the called function or a make_function node. `typingctx`, `typemap` and `calltypes` are typing data structures of the caller, available if we are in a typed pass. `arg_typs` includes the types of the arguments at the callsite. `callee_validator` is an optional callable which can be used to validate the IR of the callee to ensure that it contains IR supported for inlining, it takes one argument, the func_ir of the callee Returns IR blocks of the callee and the variable renaming dictionary used for them to facilitate further processing of new blocks. rzFound closure call: z with callee = rclosurer)compilerT)inline_closuresNrXrrr+rrrzcallee's closure = c3.K|] }|ywrLrY).0rcellgets r9 z&inline_closure_call..s6'!*6s build_tuplezAfter closure renamerErGr)Lrrfr2rcrrrrV __closure__r1pytypes FunctionTyper0rW run_frontendrr-rr rrrpr rrrrnrrqrrr.rr%rHrrrr,rrrrctypes pythonapi PyCell_Get py_objectrestypeargtypesrrgrhrb_replace_freevarsrFrJrrrrKrLrM ExceptionrrOrdr r r rsr rr rr r)/r5glblsr}r~calleerrrrrrzrreplace_freevarsrrrr{ callee_codecallee_closurerWrrrrrrrrrFrrrVrbrFrP f_return_typerRr?rSrTrrrrr r!r[s/ @r9rrBs* KKE JJqME I#$9:K&/@&I!(!8&++fooK 3nn9?9K9K&'../'))&$)G "5+6 ##$$MH++002C8K8K8M4NOI( A FM /M$IM&&()IM&&()I ""9-  $M2M"M2  ! #$ # #LH%%**113)K3334!!--sxx9Lnn\swwn?G!(HSXX  )  x()()  Ivuzz!}/@/@' JD*+ *((8)73 gu %&&11G$..GO & 0 02G 6g66Ew0 m3 54MMEK++,E :;:-/*+I+!)!;!;I.swr;c0tj|SrL)rConst)rtrurvr,s r9r[z"_get_callee_args..s#8Nr;c8tdj||)Nz.Stararg not supported in inliner for arg {} {})NotImplementedErrorrrss r9stararg_handlerz)_get_callee_args..stararg_handlers"%@GG5"# #r;defaultsz defaults = r2r,r]z)Unsupported defaults to make_function: {})&rhrarvarargrr4r,r2r is_operator_or_getitem list_varsrrrcr1r_r`rrutils pysignaturerrrfold_argumentsrr| __defaults__rrVarrsrxstrrrgrbrz)rrkr,r5rr8r{r<normal_handlerdefault_handlerr{rcallee_defaults defaults_listr default_tuple const_valss ` r9rrsy||vINN#   @C))#y}}= =  "   ( ( 3""$077 EFF#$JKK&'../   ,,V4>N # <<6 !y}}%CCzz  // 4no   /6fj.I6?? & 3 3     7/51 " (IA!!RVV,%,,Q/&,,RXXA3-GH Im+ _bff5!/37 ' 6 6 G "="'':;:%((M9:9#0#6#68&44Q78 8j(  *?FF')** 8sJ>cfd}|S)Ncvtjr(tdzdjd|Dzyy)Nz: c32K|]}t|ywrL)r)rZrs r9r\z9_make_debug_print..debug_print..)s)?Q#a&)?s)rDEBUG_INLINE_CLOSUREprintjoin)rprefixs r9r{z&_make_debug_print..debug_print's1  & & &4-"'')?$)?"?? @ 'r;rY)rr{s` r9rcrc&sA r;cFtjr|jyyrL)rrdump)r5s r9rnrn-s "" #r;cg}|jD]/\}}|j|vs|j|j1|S)z+Get all block-local scopes from an IR. )rbrrs)r- all_scopesr!r}s r9rr2sHJ + u z)   ekk *+ r;c*|jD]\}}|jtj}|D]W}t |j tj s(|j j}|t|ksJ|||_Yy)z@ Replace ir.Arg(...) with real arguments from call site N) rbr/rr0r1r2Argrtrqr-rr!r}assignsr7idxs r9r r <s| ' u""299- 'D$**bff-jj&&c$i(!#Y  ''r;c|jD]\}}|jtj}|D]}t |j tj s(|j j}|t|ksJt ||tjr |||_vtj|||j|_y)zJ Replace ir.FreeVar(...) with real variables from parent function N) rbr/rr0r1r2rrtrqrrxr,rs r9rhrhIs  ? u""299- ?D$**bjj1jj&&c$i(d3i0!%cDJ!#$s)TXX!>DJ ? ?r;ct|jD]\}}g}tt|jD]z}|j|}t |t j r|dzt|jk(sJt j|j||j|j|<|jjt j||j|D]K}|jj|jjk(s1|jj|_M t |t js)t |jt jsO|jjdk(sj|j|}y)zN Return return statement by assigning directly to target, and a jump. rXcastN)rbrangerqrfr1rReturnr0r2r,rsr rrrgrh) r-r return_labelr!r}castsr~r7rs r9r r Ys. # us5::' #A::a=D$ *AUZZ010 " $**fdhh G 1  !!"'',"AB!6D{{''4::??:%)ZZ%5%5 6T299-tzz2773JJMMV+ T" ##r;c|j}|jtj}|D]4}||jj j |j6y)zF Add variable definitions found in a block to parent func_ir. N)rr/rr0rrrsr2)r5r} definitionsrr7s r9rrosS&&Kryy)G9DKK$$%,,TZZ89r;cd}d}d}d}|t|jkr|j|}t|tjr#|r|r|j |j k(rd}n;nt|tjr||j}|j }tt||dk(rt|jdtjr|jd}|}|} t|j} nt|tjrit|j tjrE|sC|j }|j}t!||} t#tt$|| |} i} nn|dz}|t|jkrt#|xr|t'd|j ||  fS)zLook for statement like "x = numpy.array(y)" or "x[..] = y" immediately after the closure call that creates list y (the i-th statement in block). Return the statement index if found, or raise GuardException. NFrT)arraynumpyrXfind_array_call)rqrfr1rDelr2rr0rrrrrrrSetItemrr_find_unsafe_empty_inferredrc) r5r} array_varlist_var_dead_after_array_calllist_varr~rrrarray_stmt_index array_kws array_defs r9_find_arraycallrys I%*"H A c%**o  1  eRVV $I%++*F15.  ryy ),,C;;DmWd37IItyy|RVV499Q< #$  N  +bff-{{H I&w :I E5w J K I  E? c%**o B I 889('(4D)EF %y 00r;c&td}t||}|d|d|tt|tj xr|j dk(|j}t||}|d|d|tt|tj xr|j dk(|j}t||}|d|d |tt|tjxrF|jtk(xs1|jtjjjk(t|j } d |jj"g} | d k(rF| ||jj$<t||j d d } d |j d |fS| dk(rT| ||jj$<t||j d d } t||j d d } | | |fSt&)zzFind the iterator's actual range if it is either range(n), or range(m, n), otherwise return raise GuardException. find_iter_rangezrange_iter_var =  def = getiterz range_var = z range_def = rUz func_var = z func_def = )z"array comprehension"z closure ofrXrTlhs_onlyr)rcrrr1rrgrhr2rirrrmiscspecialprangerqrr,rr) r5range_iter_varrNr{range_iter_def range_var range_defrrnargsswappingstopstarts r9_find_iter_rangers$$56K#G^>!$h// !'/ ##$w q(9DIgy~~a'84HtX&&r;clt|tjr|jfd}t ||fSt|tj rd}t tj ||fSt|tjrd}t tj ||fSt|tjrd}t tj ||fSt|tjrd}t tj ||fSd}tj|)z An implementation of len(iter) for internal use. Primary use is for array comprehensions (see inline_closurecall). c|\}td}tj||||}|jj}t ||||j |jSrW)r&r create_struct_proxycounttyper!load) contextbuildersigrr2 iter_typeiterobjint_typeval_types r9codegenz#length_of_iterator..codegenslHU&x03I.codegensJHU++EJJ7F&w!eLG%gw M Mr;cB|j\}|\}|jtj}|j |||}|j }t ||||j} tj|| j} t|||| dS)N)r2r) rrrr make_helper array_typer'rr unpack_tupleshaper!) rrrritertyr2rrarraytyaryrs r9rz#length_of_iterator..codegensIVHU++EJJ7F))'6)GG''G%*W%gwgmmLC((#)).codegensKIV&&G++EJJ7F /K%gw L Lr;c|\}|jtj}ddlm}||||j d|}t ||||jS)Nrr$)rrrnumba.typed.listobjectr%rr!r)rrrrr2rr%rs r9rz#length_of_iterator..codegensMHU++EJJ7F ?&w!eLG%gw M Mr;zdUnsupported iterator found in array comprehension, try preallocating the array and filling manually.) r1rRangeIteratorType yield_typer#ListIterr ArrayIterator UniTupleIterListTypeIteratorTyper TypingError)rvalrr8rs @r9length_of_iteratorrs #u../>> C3'00 C ( N S)722 C,, - JS)722 C++ , MS)722 C33 4 N S)722?  %%r;c td}tt|jdk(t t |j}t ||j|\} } } d} d} d| vrtt| dtjt|| d} tt| tjxr| jdk(t|| j} t|| }|d| d|t|tjr%|jdk(rt||j}tt|tjxr|jd k(tt|jd k(g}|j D]8}|j#|Dcgc]}|j$|v}}t'|s:|j|}|d ||j)tj*D]}|j}t|tjs*|jd k(s:t||j,}t|tjsk|jdk(s{|j.d k(st||j}|d|||u||us|j1|||f;tt|dk(|d \}}}t3d|j5|j$D}|d||j6t3|gzt||j6t3|gzk(g}g}|j|j$}|j)tj*D]}|j}t|tjs*|jdk(r;t||j}|d||j1|jt|jdk(s|j1|j8tt|dk(xrt|dk(|d } |d }!tt|j6dk(|jt t |j6}"|"j:}#|"j<}$|"j>}%g}&g}'d}(tAt|"j dz D]y})|"j |)}t|tj*r=|jus|(|j|'r|'j1|j8i|&j1|{|d|'tCtD|| |}*|$jGd|%}+|*r |*d d k(r|!}+n2|&j1tI||+tjJd|%|%|$jGd|%},|*rn|*\}-}.}/|-d k(r|.}0n1tjjMtNjP|.|-|%}0|rt|/tjRrd|/_*tV|/_nv|rn|$jGd|%}1|&j1tI||1tjRdtX|%|%tjj[|1| fd|%}0nt\|&j1tI||,|0|%|$jGd |%}2|&j1tI||2tjj_|,g|%!|%|$jGd"|%}3|$jGd#|%}4| r| r|$jGd$|%}5|$jGd|%}6|&j1tI||5| |%|&j1tI||6tjja|5| j.|%|%|&j1tI||4tjRd%tbjd|%|%d|6fg} nB|r:|&j1tI||4tjRd&tf|%|%g} nt\|&j1tI||3tjj[|4|2fti| |%|%|'D]}7|&j1tI||7|3|%!|&j1|#|&|"_|*r|*d d k7r|j:}#t|#tjjsJ|#jl}8|j|8}9|9j>}%|9j jod tI||+tjjMtNjP|!|*d |%|%n|j>}%|j:}#|j d d}&|$jGd'|%}:|$jGd(|%};|&j1tI||;tjJd|%|%|&j1tI||:tjjMtNjp|+|;|%|%|&j1tI||+|:|%|&j1|#|&|_tAt|j D]c})|j |)|us|d)tjr|3|+|jjtd |j>*|j |)<e|j|j | }t|tj*rYt|jtjr5|3|_|jg|jv|j8jT<y+cc}w),aLook for array(list) call in the exit block of a given loop, and turn list operations into array operations in the loop if the following conditions are met: 1. The exit block contains an array call on the list; 2. The list variable is no longer live after array call; 3. The list is created in the loop entry block; 4. The loop is created from an range iterator whose length is known prior to the loop; 5. There is only one list_append operation on the list variable in the loop body; 6. The block that contains list_append dominates the loop head, which ensures list length is the same as loop length; If any condition check fails, no modification will be made to the incoming IR. inline_arraycallrXNdtyperqz list_var = rr build_listrzcheck loop body block rUrsz list_def = c3&K|] \}}| ywrLrY)rZlbs r9r\z$_inline_arraycall..Xs.is_removed|s7 c266 " 66SXX% r;zremoved variables: rtr}r)fnrrhsr,r len_funcrr+rY size_tuplerbr,r empty_func dtype_modemptyunsafe_empty_inferred next_indexonezReplace append with SetItem)rrtr2r,T) "$$67K C Oq !d4::&'J,; +-)H IM) 9W-rvv67#7Ig,>?  9bgg.L9<<93LM&w @ !'84L xLA,(\__-F%g|/A/AB  J|RWW - , OO| +- C "" #q ()G:=e9LMAAHH/MM#$ u%,e4$$RYY/ GD::D$(TWW->)'499=x1hkkY6N$MMX5-gx~~FH x (L 8:</)00%1EF GG. C! "a '(4Ea4H1 k > ?@IO..-K&&ryy14zz dBGG $ww*$)'4::>M84  ,L(&&t{{34 C Na  =C$8A$=>|H$Q'N  C  "#T$,,%7 89J&&J   E ..C EG3z'!+ ,q! tRYY 'x':djj'+J NN4;; ' LL  %w/ &7CIw,IYq\Q&"   _Wi%'XXBC%@#G H~~fc*H&/#t^ A:Hww}} $E),%.H Z B"3N #2N   >>*c:L LL,)+3G3E7:*<*- . / ww||L8+rs|KH  LL(HcBC^^L#6N LL.$$H:3$?FGw,I c2J]{C8 NN7C0  _ ]M38 9 _ Y GGOOM9>>3 ?F G  _ Z7BHH#!FM Ny)*   LL 13H!#   I  LL)j>*;T)_"%'(+-. D _Wc9cBCD LLJO Q<1 %//Jz2995 65!((H..*C''C HHOOYGGMMX\\~&/l"=  oo ++   2& c:nnUC( _WcXXA#.5 6  _WnWW]]hll s'*#,-02 3  _WiMN Z  3|(() *F   Q ; . 5 6#%:: !'',,Q/[__$FL  a F >>* % * *+; r5s r9r>z)_fix_nested_array..find_array_def4se !#.+*+C9 grww '0'7Cy(%gmm44r;c (td}jD]\}}|j}|j}t }t t |D]}||} t| tjs$|j| jj| j|usXg} |D]J} | j|vs,| j|vr@| jj|vr%|| jd| j| c|| jdt!| j} t| tj"r| j$} |j'd| }tj"| j| }t)||| }g}|j+|d||j||j+||d||_| j|Gt,| ccSt,)zDouble check if all variables in varlist are defined before expr is used. Try to move constant definition when the check fails. Bails out by raising GuardException if it can't be moved. fix_dependenciesz already definedz not yet definedrN)rcrbrrfr rrqr1rr0rrrr2defmaprsrrxr,rrextendr)rvarlistr{r!r}rrfdefinedr~inst new_varlistrvar_defr,r new_const new_vardefnew_bodyr-r5livemapusedefss r9rCz+_fix_nested_array..fix_dependenciesBs ((:; "LLN# +LE5KKE::DeG3t9% +AwdBII.KK 0 01zzT)&( #*9C!$G 3!$WU^!;&)hh'..2G&G +CHH6H I + 2 23 7 +CHH6H I*8#((*K#-grxx#@*-''C.3nnY.LG020LI1@(/)S2JJ/1H$,OOD!H$=$,OOJ$?$,OODH$=19EJ$/$6$6w$?*8$8192 +*? + # +Jr;c(tt|tjtt|jtj t d}|d||j} |}|d|t |j}|d|tt|tj|jdk(r9t |j}tt|tjtt |t |jd}tt|tjxr|jdk(|d||jDcgc]}t |d }}|d |t |jd}tt|tjxr|jdk(|d | ||}|xj|z c_ d |_ tj|_t |d |_|j"|_|j$d=|j$d=|j$d=|j$d=y cc}w)aFor assignment like lhs[idx] = rhs, where both lhs and rhs are arrays, do the following: 1. find the definition of rhs, which has to be a call to numba.unsafe.ndarray.empty_inferred 2. find the source array creation for lhs, insert an extra dimension of size of b. 3. replace the definition of rhs = numba.unsafe.ndarray.empty_inferred(...) with rhs = lhs[idx] fix_array_assignzfound SetItem: zfound lhs_def: zfound rhs_def: rrr]z dim_def = Trz extra_dims = zsize_tuple_def = r?rirr~r)rr1rrr2rrcrrrgrhrrrbrr?rrt_kws) r7r{rlhs_defrhs_defdim_defr extra_dimssize_tuple_defr>rCr5s r9rQz+_fix_nested_array..fix_array_assignos  4,- 4::rvv./'(:; %t,kk %%w/ $**5%w/ 7BGG,- :: $Wgmm ',,q/: 7BGG,L}1LML'*&}}/%Wa$?/ /OZ0'aA >27733!!]2 4'8%njA  * %% &wdC   LL LL LL " LL )/sJN) r-rrrrpr r rDrrfrr ) r5rr! empty_deadmaprQr}r7r-r>rCrNrOs ` @@@@@r9rvrv*s^^F !& )Cv&GfkkmDU5#%.DEM$S&'..-PG +Z1f!0(u%JJ (D%t, !!$' ((cEsC*cf|g|j|j<tj|||S)N)r2rr,)rrrr0)r5rr2r,s r9rrs+&+WG" 995# 66r;zafter-inferencec.eZdZdZfdZdZdZxZS)RewriteArrayOfConstszThe RewriteArrayOfConsts class is responsible for finding 1D array creations from a constant list, and rewriting it into direct initialization of array elements without creating the list. cN|j|_tt||i|yrL)rsuperr[rR)rQr@rr __class__s r9rRzRewriteArrayOfConsts.__init__s# "D2D@C@r;ct|dk(ry||_tt|||j|||_|j duS)NrF)rq crnt_blockr_inline_const_arraycallrrM)rQr5r}rrs r9matchzRewriteArrayOfConsts.matchsF y>Q 5ug"nngyB }}D((r;cP|j|j_|jSrL)rMr`rfrQs r9applyzRewriteArrayOfConsts.applys#}}r;)rrrrrRrbre __classcell__)r^s@r9r[r[sA)r;r[c  td |j fd}Gddt}|}|jD]b}t |t j rt |jt jrn|jj|jvr|jj|jj|jj|t |jt jrO|j} | jdk(rr|j!| j"D cgc]} | jc} |_|jjg|_ |jj|c| jdk(r| vrt'||j| |j|j|j(rtd|_t |t j,rP|j} | |j$vr|j(j| | |jvr |j.j| |jj1| |jj||jgk(rg} |jD]}t |t j r"|jj|j.vs2t |t j,r|j|j.vrr| j|| |_ g|_d|_%|jj||j3|sS|j!e|j*r |jSdScc} w) a|Look for array(list) call where list is a constant list created by build_list, and turn them into direct array creation and initialization, if the following conditions are met: 1. The build_list call immediate precedes the array call; 2. The list variable is no longer live after array call; If any condition check fails, no modification will be made. inline_const_arraycallc " tt"|}t|xr|ddk(xr|ddk(t|jdj|v|j }tt |tjxr|jdk(|j}|jd}$|j} !d|d|| j} t"|\} } t| } #jd|}#jd|}tj}tj |d}|$|j<|$|j<|j#t%"|t'j(| | ||j#t%"|t&j*j-|g| |tj.| }#jd |}t1t2j4} j7||fd |i|$|j<|j#t%"|t'j8d t2j4| |#jd|}tj:j=t2$|j<t'j8dt2|}|j#t%"|||#jd|}|$|j<t?| }|dk(rd}t&j*jA|||}|j#t%"|||t&j*jC|||gi| }tEjF| |||<|j#t%"|||tI| D]}#jd|}tj}|$|j<|j#t%"|t'j(|||t'jJ||| ||}tEjFtjL| || |<|j#||jO|y)zCheck to see if the given "array_var" is created from a list of constants, and try to inline the list definition as array initialization. Extra statements produced with be appended to "stmts". rXrrrzinline array_var = z list_var = rrr+rrrrz $np_g_varrz $np_typ_varboolbool_rtT)(rrrrrr7r1rArrayCompatiblendimr,rrrqrrUniTuplersrrrxrgr]DTyperrrresolve_function_typerrModulerrqrUrr#rrnonerE)%rrr/rdelscallnameret_typer,r array_typrseqr?rr1r5size_typsize_tuple_typnptyperfntyg_np_varg_nptyp_var dtype_strnp_typ_getattr empty_callr~r0 index_typsetitemrrr{r5rrs% r9 inline_arrayz-_inline_const_arraycall..inline_arrays6NXa[G3N w8NO ! !!Y./T?.. 8U%:%:;# " $hh99Q<INN+ )9nhO$Wh7Q3x>>&#. c:::!4!) '5##$ GXHHTs3S : ;  G^GG//xjc/J ! "U#^^L#6 )%%dXK'69JK#'   GZIIgrxxSA3 H I>>+s3!&!2!22!6 yyr3' _WhcBC..4 & J  I9cB _Wg~sKLWW\\*x.A23\O & 0 0Hf M * _WiSIJt "Aw4I I&/GINN # LLBHHQ4DcJ LjjIs1vsCG!'!1!1%**i2;U"DIg  LL ! "  Tr;c"eZdZdZdZdZdZy)&_inline_const_arraycall..Statez This class is used to hold the state in the following loop so as to make it easy to reset the state of the variables tracking the various statement kinds cXg|_g|_g|_g|_g|_d|_y)NF)r dead_vars list_itemsr/rsryrds r9rRz/_inline_const_arraycall..State.__init__7s2 DN DN DODJDI!DMr;c<g|_g|_g|_g|_y)zV Resets the internal state of the variables used for tracking N)rrrrsrds r9resetz,_inline_const_arraycall..State.resetGs  DNDN DODIr;ct|jDcgc]}|j|jvc}Scc}w)z Returns True if the list being analysed is used between the build_list and the array call. )rrr)rQrHrs r9 list_var_usedz4_inline_const_arraycall..State.list_var_usedPs1 $..:JKQ$..0KL LKs>N)rrrrrRrrrYr;r9Stater0s  "   Mr;rrrUTN)rcrobjectrfr1rr0r2rrrrsrr/rgrhrrbrrrsryrrr r)r}r5rrrrrr@rHrr removed_varrfr{rs ```` @@r9raras$$<=K KKE^^@%M%MN GE 7 dBII &$**bff-::??eoo5OO**4;;+;+;<KK&&t,DJJ0zz77l*KKM8< 'C1'CE$'+{{'7'7&8EOKK&&t,WW&49+<\4;;"[[%//5::G)- bff %**Ke... !!$'/&&{3&&{3 ""4(??b( D % *'bii8![[--@'bff5!ZZ5??:$ D) *#'EK&(EO%)EN 4   t $ KKMo7r ..5;;2d2[(DsO )NNNNNNNT)FF)Urr_rrbnumba.core.analysisrr0rrrrrr r r1r numba.core.ir_utilsr r rrrrrrrrrrrrrrrrrrr numba.core.imputilsr!numba.core.extendingr"numba.core.typingr#numba.cpython.listobjr%numba.cpython.rangeobjr&numba.np.arrayobjr'r(numba.np.unsafe.ndarrayr)rrrrnumba.misc.specialrmr:rHrrJrrrrrcrnrr rhr rrrrrtrrvrregister_rewriteRewriter[rarYr;r9rs] !!!0*3*'21(KA GFGT0Q+6Q+hEI?CIM)-\#~BJ  ' ? #,9.1bD 8& 8&vKP!Up5|(~7 ,-8++.,M3r;