X-Ph+dZddlmZddlmZmZmZmZddlm Z m Z m Z m Z ddl mZddlmZmZmZmZddlmZmZmZddlmZmZdd lmZmZmZdd lm Z d-dZ!d.dZ"d/dZ#d.dZ$d0dZ%d1dZ&d2dZ' d3d4d%Z(d.d&Z)d5d)Z*d6d,Z+d S)7aGenerate 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_NAME SELF_NAME bitmap_name)ClassIR)CallGetAttrSetAttrValue) RInstancebitmap_rprimitiveobject_rprimitive) IRBuilder SymbolTarget)FuncInfoGeneratorClass ImplicitClass)AssignmentTargetAttrbuilderrreturnr clt|jd|jd}t ||jt <|jjr,t |jdj |jt<|g|_ ||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_generated)r fn_infonamespaced_name module_namer attributesr is_nestedfn_infos env_classr mroclassesappend)rr&s W/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypyc/irbuild/env_class.pysetup_env_classr+s ? * * , ,222G4GVZI'0 &:&:I# X/88H8L8V.W.W ]+KIM )GO O9%%% Nonect||jjrt|d|jjdSt|d|jdS)zJGenerate, instantiate, and set up the environment of an environment class.F)localbaseN)instantiate_env_classr r$add_args_to_envcallable_class)rs r*finalize_env_classr4;s]'"""  Du7?3QRRRRRRu7?CCCCCCr,rcn|t|jjjg|jjj}|jjrZ||jj_ |t|t|jjj |jjjn ||j_ |S)zTAssign an environment class to a register named after the given function definition.) addr r r&ctorfitemliner$r3 _curr_env_regrr prev_env_reg)r curr_env_regs r*r1r1Hs;; W_ & +R1F1KLLL 57C&4 .;%*       )5% r,ct|d|j}|j}|jrIt ||jt |tr!|jrt|||jdSdSdSdS)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)r/N) r2r r8r$load_outer_envsr3 isinstanceradd_nested_funcs_to_envsetup_func_for_recursive_call)rr r8s r*load_env_registersrB^sG4((((oG MER!7888 eW % % R'*I R )'5':P Q Q Q Q Q RR R R R Rr,r0 outer_envdict[SymbolNode, SymbolTarget]c|t|t|jjj}t |jts J|d| D]N\}}|j|jj j |j <t||j }|||O|S)aLoad the environment class for a given base into a register. Additionally, iterates through all of the SymbolNode and AssignmentTarget instances of the environment at the given index's symtable, and adds those instances to the environment of the current environment. This is done so that the current environment can access outer environment variables without having to reload all of the environment registers. Returns the register where the environment class was loaded. z must be of type RInstance)r6rr r r8r9r?typeritemsclass_irr#namer add_target)rr0rCenvsymboltarget symbol_targets r*load_outer_envrOrs ++gdM7?3H3MNN O OC ch * *NNs,N,N,NNNN#//++224:K$V[1,S&+>> 6=1111 Jr,rclt|jdz }|dkre|j|}t|trt ||j||_nt ||j||_|j}|dz}|dkr+|j|}t |||}|dz}|dk)dSdS)N) lenbuilders symtablesr?rrOr<r;self_reg)rr0indexrCenv_regs r*r>r>s  ! !A %E qyy%e, dN + + R .w8I9 U UD   .w y Q QD #   !))%e,  '9==   !))))))r,argslist[Argument]intcd}|D]F}||jj}|jr|jr|dz }G|t dz zt zS)NrrR) type_to_rtypevariablerF error_overlapkind is_optionalr)rrYnargts r*num_bitmap_argsresk A  ! !#,"3 4 4 ? sx3355  FA q !k 11r,TNr/boolFuncInfo | ImplicitClass | NonereassigncV|j}|jj}t||}|r|D]>}||jj}||j|d?tt|D]9} |tt| td:dS|D]g}t||js|jrI||jj}| Jd||j|||hdS)NT)is_argz,base cannot be None for adding nonlocal argsrh)r r8 argumentsrer]r^rF add_local_regreversedrangerr ris_free_variable is_generatoradd_var_to_env_class) rr/r0rhr rYnbrcrtypeis r*r2r2s\ oG = "D $ ' 'B [ D DC))#,*;<z!add_vars_to_env..s WXW]r,)keyFrkN)r rqgenerator_classr$ in_non_extr3r8free_variablessortedr?rr]rFrrencapsulating_funcsrr)r env_for_funcvarrt nested_fns r*add_vars_to_envrsM.5_L#66  "6go&@65  666'01FGM]M]^^^ W WC#s## W--ch77,,S%PU,VVV ;;; 4W_5JK  I)W--  ,,0,-<;  r,fdefrc|jdj}||j|j|j<t |tr/|t|j td}n|j }|t||jd}| |t}|||ddS)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. rN)r%r&r]rFr#rIr?rr6rr<r r;rmrassign)rrr0prev_envr;valrMs r*rArAs#-H%,%:%:49%E%EH "$''){{74+rer2rrArpr,r*rs"#"""""999999999999KKKKKKKKKKKK%%%%%%666666666666KKKKKKKKKK99999999IIIIIIIIII666666: D D D D,RRRR(2.2222,0 [[[[[.    F$$$$6WWWWWWr,