pPj=tdZddlmZddlmZmZmZmZddlm Z m Z m Z m Z m Z ddlmZddlmZmZmZmZddlmZmZmZddlmZmZdd lmZmZmZdd l m!Z!dd l"m#Z#dd Z$dd dddZ%d dZ&dd!dZ'dd d"dZ(d#dZ)d$dZ* d% d&dZ+ d'dZ,dd!dZ-d(dZ.d)dZ/y)*aGenerate classes representing function environments (+ related operations). If we have a nested function that has non-local (free) variables, access to the non-locals is via an instance of an environment class. Example: def f() -> int: x = 0 # Make 'x' an attribute of an environment class instance def g() -> int: # We have access to the environment class instance to # allow accessing 'x' return x + 2 x = x + 1 # Modify the attribute return g() ) annotations)ArgumentFuncDef SymbolNodeVar) BITMAP_BITS ENV_ATTR_NAMEGENERATOR_ATTRIBUTE_PREFIX SELF_NAME bitmap_name)ClassIR)CallGetAttrSetAttrValue) RInstancebitmap_rprimitiveobject_rprimitive) IRBuilder SymbolTarget)FuncInfoGeneratorClass ImplicitClass)AssignmentTargetAttr)get_func_target_symbolcJt|jjd|jdd}d|_t ||j t<|jjr|jdjht |jdj|j t<|jjr|jjt|g|_||j_ |j"j%||S)aGenerate a class representing a function environment. Note that the variables in the function environment are not actually populated here. This is because when the environment class is generated, the function environment has not yet been visited. This behavior is allowed so that when the compiler visits nested functions, it can use the returned ClassIR instance to figure out free variables it needs to access. The remaining attributes of the environment class are populated when the environment registers are loaded. Return a ClassIR representing an environment for a function containing a nested function. _envT) is_generatedis_final_class)r fn_infonamespaced_name module_namereuse_freed_instancer attributesr is_nestedfn_infos _env_class env_classr contains_nested!attrs_to_keep_alive_on_completionaddmroclassesappend)builderr)s \/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypyc/irbuild/env_class.pysetup_env_classr2%s ?? * * , -T2 I &*I"&/ &:I#  W%5%5b%9%D%D%P/88H8H8L8V8V.W ]+ ?? * *  7 7 ; ;M JKIM )GOO OO9% T)add_argscV|jjs t|}n|jj}|rj|jjsT|jj r%t |d|jj||St |d|j||S)zJGenerate, instantiate, and set up the environment of an environment class.F)localbaseprefix)r!#can_merge_generator_and_env_classesinstantiate_env_class curr_env_regis_comprehension_scoper&add_args_to_envcallable_class)r0r8r4env_regs r1finalize_env_classr@Hs ?? > > @'0//.. >> ?? $ $ u7??+I+IRX  N G5wv V Nr3ct|jt|jjjg|jj j }|jjr|jjsz||jj_ |jt|t|jjj|jj j |S||j_ |jjr|jdnd}|<|j0|j r|j"j$}n|j}nd}|?|jt|t||jj j |S)zTAssign an environment class to a register named after the given function definition.r N)r,rr!r)ctorfitemliner&r<r> _curr_env_regrr prev_env_regr'r( is_generatorgenerator_classr;)r0r;parentparent_env_regs r1r:r:\sP;; W__ & & + +R1F1F1K1KLL  )O)O7C&&4 ..;;%%**   2 )5%)0)B)B!!"%  &"3"3"?""!'!7!7!D!D!'!5!5!N  % KK m^W__EZEZE_E_`  r3c4t|d||j}|j}|jrf|jdj Lt ||jt|tr%|jrt|||jyyyyy)aGLoad the registers for the current FuncItem being visited. Adds the arguments of the FuncItem to the environment. If the FuncItem is nested inside of another function, then this also loads all of the outer environments of the FuncItem into registers so that they can be used when accessing free variables. T)r6r8r N) r=r!rCr&r'r(load_outer_envsr> isinstanceradd_nested_funcs_to_envsetup_func_for_recursive_call)r0r8r!rCs r1load_env_registersrPsG47ooG MMEW--b1<<H!7!78 eW %'*I*I )'5':P:P Q+J % Ir3Fborrowc|rGt|jtsJ|jjj t sJ|j t|t |jjj|}t|jts J|d|jD]\}}t|trZt|jjtr6|jjj|jjurq|j}|j|jjj|<t||}|j!|||S)aLoad the environment referenced by "base" and bind its symbols. "outer_env" may contain registers and attributes from multiple environment levels. Bind only attributes stored directly on the loaded environment, since the other targets cannot be accessed through it. If "borrow" is true, return a borrowed reference. In that case the environment link on "base" must be final so that the reference remains valid. rQz must be of type RInstance)rMtyperclass_ir is_final_attrr r,rr!rCrDitemsrobjattrr% add_target) r0r7 outer_envrRenvsymboltarget attr_name symbol_targets r1load_outer_envras* $))Y///yy!!// >>> ++gdM7??3H3H3M3MV\] ^C chh *Nse3M,NN *#//+ 26#78fjjooy9zz''sxx/@/@@ KK 28++$$Y/,S)< 6=1 2 Jr3ct|jdz }|dkDxs |dk(xr|jdj}|r|j|jk|j |}t |trt||j||_ nt||j|d|_ |j}|dz}|dkDrB|j|jy|j |}t||}|dz}|dkDrAyy)NTrQ) lenbuildersr'r*r( symtablesrMrrar;rFself_reg)r0r7index has_outerr[r?s r1rLrLs    !A %E QeqjPW-=-=a-@-P-PIW%%e,77C%%e, dN + .w8I8I9 UD !/w yY] ^D ##   !)   E " - - 5 %%e,  '9=   !)r3cd}|D]T}|j|jj}|js5|jj sP|dz }V|t dz zt zS)Nrrd) type_to_rtypevariablerT error_overlapkind is_optionalr)r0argsnargts r1num_bitmap_argsruse A  ! !#,,"3"3 4 ??sxx335 FA q !k 11r3Nc |j}|jj}|rt||}|D]E}|j |j j } |j|j | dGtt|D],} |jtt| td.y|D]}t||j s|j |j j } |Jd|j|j | |||j|j |y)NT)is_argz,base cannot be None for adding nonlocal argsreassignkeep_alive_on_completionr8)r!rC argumentsrurlrmrT add_local_regreversedrangerr ris_free_variableadd_var_to_env_classis_captured_by_nested_func) r0r6r7ryr8r!rqnbrsrtypeis r1r=r=s1ooG == " "D Wd + DC))#,,*;*;z!add_vars_to_env.."s qvvr3)keyFTrx)ryrzN)r!rGrHr& in_non_extr<r>rCfree_variablessortedrMrrrlrTencapsulating_funcssetrrr, is_coroutiner rrrrrh) r0r8r! env_for_funcvaradded nested_fn target_symbol nested_prefix keep_alives r1add_vars_to_envrsooG-4L..   w117;Y;Y-- }}...'00?EUV C#s#,,))#((3 "-1! - }}333!$ 44W]]C I)W- 6y A  E) -( !' ))Y-C-C$>M-g}E ''0R0RS`0a66%)//88!&1; 700%)$!&1;, 11 4r3c|jdj}t|}|jdj |}t |t rVt |trFt |jjtr"|jjj|ury|j}|j}t |tr+|jt!|j"t$|}n |j&}|jt!|||} |j)|t*}|j-|| |y)a.Enable calling a nested function (with a callable class) recursively. Adds the instance of the callable class representing the given FuncDef to a register in the environment so that the function can be called recursively. Note that this needs to be done only for nested functions. r N)r'r)rrggetrMrrrXrTrrUrYrDrr,rr;r rFr|rassign) r0fdefr7prev_envrr^r_rDrFvals r1rOrOQs#--H*40M   r " & &} 5F }g .&"67&**//95 ::?? # #8 3 I 99D$'{{74+<+rs1"#99&66KK9II65 FQU(!HR2 # # #.#  #  #L82,0    *     >b b#(b38bDHb b(<~"&JWr3