pPjdZddlmZddlmZddlmZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZddlmZmZmZmZddlmZmZmZmZdd lmZm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4dd l5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;dd lZ>m?Z?ddl@mAZAmBZBmCZCmDZDddlEmFZFmGZGddlHmIZImJZJmKZKmLZLddlMmNZNmOZOddlPmQZQddlRmSZSddlTmUZUmVZVmWZWddlXmYZYmZZZm[Z[m\Z\ddl]m^Z^ddl_m`Z`maZadAdZbdBdZcdCdZddDdZe dE dFdZf dGdZgdHd Zh dI dJd!ZidKd"ZjdLd#ZkdMd$Zl dNd%ZmdOd&ZndPd'ZodQd(Zpdd) dRd*ZqGd+d,eZrdSd-Zs dTd.Zt dUd/Zu dVd0Zv dWd1ZwdXd2ZxdYd3ZydZd4Zz d[d5Z{ d\d6Z| d]d7Z} d^d8Z~d_d9Zd`d:Zdad;Zdbd<Zdcd=Zddd>Z ded?Z ded@Zy)faTransform mypy AST functions to IR (and related things). Normal functions are translated into a list of basic blocks containing various IR ops (defined in mypyc.ir.ops). This also deals with generators, async functions and nested functions. All of these are transformed into callable classes. These have a custom __call__ method that implements the call, and state, such as an environment containing non-local variables, is stored in the instance of the callable class. ) annotations) defaultdict)Sequence) NamedTuple) ArgKindClassDef DecoratorFuncBaseFuncDefFuncItem LambdaExprOverloadedFuncDefTypeInfoVar) CallableTypeType UnboundTypeget_proper_type) FAST_PREFIX LAMBDA_NAMEPROPSET_PREFIX SELF_NAME)ClassIRNonExtClassInfo)FUNC_CLASSMETHOD FUNC_NORMALFUNC_STATICMETHODFuncDeclFuncIR FuncSignature RuntimeArg) BasicBlock ComparisonOpGetAttrInteger LoadLiteralRegisterReturnSetAttrUnbox UnreachableValue) RInstancebool_rprimitivec_int_rprimitivedict_rprimitiveint_rprimitiveobject_rprimitive) IRBuildercalculate_arg_defaultsgen_arg_defaults)add_call_to_callable_classadd_get_to_callable_classinstantiate_callable_classsetup_callable_class)FuncInfoGeneratorClass)add_vars_to_envfinalize_env_classload_env_registerssetup_env_class)gen_generator_funcgen_generator_func_body)AssignmentTarget)get_func_target_symbol)dict_get_method_with_none dict_new_opexact_dict_set_item_op)generic_getattrgeneric_setattrpy_get_item_op py_setattr_op)register_function)is_same_method_signature is_same_typec<|jj||jj}t |||j |\}}|r'|j t||||jt|||j||jyN) mapper fdef_to_sigoptionsstrict_dunders_typing gen_func_itemnameassignget_func_targetlinemaybe_insert_into_registry_dict add_function)builderfdefsigfunc_irfunc_regs [/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypyc/irbuild/function.pytransform_func_defrabsy .. $ $T7??+P+P QC%gtTYYDGXw5xK#GT2 $)),cV|jsJ|j|jyrO)implaccept)r[os r`transform_overloaded_func_defrgns 66M6 NN166rbcz|jj|j|jj}t ||j|jj |\}}d}|rSt||j|}|jt||j||jjns|j|jvr[|jjjdd}|j||j}t||j|}|U|jt |j#|j%|jj |g|jt'||j|j(j+|y)N.)rPrQfuncrRrSrTrUload_decorated_funcrVrWrXfdefs_to_decoratorsfullnamesplitload_global_strcall_crFload_globals_dictload_strrY functionsappend)r[decr]r^r_decorated_funcrU orig_funcs r`transform_decoratorrytsI .. $ $SXXw/T/T UC%gsxxLGX#'N,WchhIw9>388==Y W00 0xx  &&s+B/++D#((; ,Wchh J! "  & & ('*:*:388==*I> Z    $GSXX6 W%rbc lt|j|}t|tsJ|g}t |j |j D]_\}}||j_|jt|jj|j||ja|j|j}t||}t |j"}|xj"dz c_t%||||\} } | J|j&j| | S)N)rtypes isinstancerzip arguments arg_typesvariabletyperur!rU type_to_rtypekindret_typer rlambda_counterrTrt) r[exprtyp runtime_argsargarg_typerfsigfnamer^r_s r`transform_lambda_exprrs '--- .C c< (-#- (LT^^S]]; X$  s||(('*?*?*I388 T  $$S\\2H x 0DmG223 4E a%gtUDAGX    W% OrbNFc Rd}|jvxst|t}|jj v}|j v} |j vd} t|} d} rAjjj} | j xr| } j} r t|}n|}t||| t||| | |  }|j }j#|j$|r`j&j(}t|t*sJ|jj,|}t/|j&_|s|r%j&j3s t5|s| r t7|r#t9fd\}}t;||nt=\}}rKj>jA|t|t*sJ|tC||j|S||fS)aGenerate and return the FuncIR for a given FuncDef. If the given FuncItem is a nested function, then we generate a callable class representing the function and use that instead of the actual function. if the given FuncItem contains a nested function, then we generate an environment class so that inner nested functions can access the environment of the given FuncDef. Consider the following nested function: def a() -> None: def b() -> None: def c() -> None: return None return None return None The classes generated would look something like the following. has pointer to +-------+ +--------------------------> | a_env | | +-------+ | ^ | | has pointer to +-------+ associated with +-------+ | b_obj | -------------------> | b_env | +-------+ +-------+ ^ | +-------+ has pointer to | | c_obj | --------------------------+ +-------+ NF) fitemrU class_name namespace is_nestedcontains_nested is_decorated in_non_extadd_nested_funcs_to_env)rc &t|||SrO) gen_func_ir)argsblocksfn_infor[cdefis_singledispatchr]s r`zgen_func_item..s+vsGT;L+rb)" nested_fitemsr}r encapsulating_funcskeysrmsingledispatch_implshas_nested_func_self_referencerP type_to_irinfo is_ext_classrUsingledispatch_main_func_namer: gen_func_ns is_generatorenterrrrr fdef_to_generatorr;generator_class#can_merge_generator_and_env_classesr?r9r@rA gen_func_bodyrtrugen_dispatch_func_ir)r[rrUr]rmake_ext_methodr_rrrrrrir func_namerrgenerator_class_irr^rs` `` @r`rTrTsX"H ...O*UJ2OIw::??AAOG777L!=!==JOP  )%)050)#GUGLL$LL H rbc t|t||jjr t |t ||j |jjj|j|jd}|j\}}}}} t||||| ||\} } t|| | || | fS)Nrj)r>r5rrr=r<rerbodymaybe_add_implicit_return symtablesleaverr4) r[r]rrsymtabler_rrrr^r_s r`rr&swW&&7#G NN7??((--. %%'  $H)0&D!VXw#GT63O`aGX7GXx@ H rbctdjj|tDrytfdjj|gDS)zDoes a nested function contain a self-reference in its body? If a nested function only has references in the surrounding function, we don't need to add it to the environment. c3<K|]}t|tywrO)r}r ).0syms r` z1has_nested_func_self_reference..Es Y:c8 $ YTc36K|]}t|ywrO)r)rnestedr[s r`rz1has_nested_func_self_reference..Gs   'w7s)anyfree_variablesgetsetr)r[rs` r`rr?sZ  Y0F0F0J0J5RURW0X YY 1155eR@ rbc xd}|js |jr+t|||||}t||t ||}||fS|j } t | tsJ| |jj| } |rZ|jt| jzk(r:|jj|jj|j} |js|r|dn |j} t!|j| |j"|| j$| j&| j(| j*| j,| j.| j0 } t3| ||| j4| j}||fSt3| ||| j4| j}||fS)aGenerate the FuncIR for a function. This takes the basic blocks and function info of a particular function and returns the IR. If the function is nested, also returns the register containing the instance of the corresponding callable class. N)is_prop_getteris_prop_setterr is_coroutineimplicitinternal)traceback_name)rrr6r7r8rr}r rP func_to_declrUrrr method_declsrr module_namerrrrrrrrrX) r[rrr]rris_singledispatch_main_funcr_r^r func_declrs r`rrMs "HG..,WdFCQ!'73-gw?4 X 1 %)050)NN//6 GLLK)..$@@11$))<II',,WI   #>!%499J  ##(77(77&33&33"++"++ IYfejjQVQ[Q[\G X YfejjQVQ[Q[\G X rbc |jdz}|jj|j}|j}d|jd}|j r|j |dz||jr|j |dz||j||td5|jdt}|jt|j|g|}tt} } td t|} |j!t#|| t"j$|} |j'| | | |j)| |j!t+|||j)| |j-|j|j|gt|} |j!t+| |d d d y #1swYy xYw) ag Generate a wrapper function for __getattr__ that can be put into the tp_getattro slot. The wrapper takes one argument besides self which is the attribute name. It first checks if the name matches any of the attributes of this class. If it does, it returns that attribute. If none match, it calls __getattr__. __getattr__ is not supported in classes that allow interpreted subclasses because the tp_getattro slot is inherited by subclasses and if the subclass overrides __getattr__, the override would be ignored in our wrapper. TODO: To support this, the wrapper would have to check type of self and if it's not the compiled class, resolve "__getattr__" against the type at runtime and call the returned method, like _Py_slot_tp_getattr_hook in cpython. __getattr__ is not supported in classes which inherit from non-native classes because those have __dict__ which currently has some strange interactions when class attributes and variables are assigned through __dict__ vs. through regular attribute access. Allowing __getattr__ on top of that could be problematic. __wrapperz&"__getattr__" not supported in class " " because it allows interpreted subclasses#it inherits from a non-native classTrattrrN)rUrPrrrXallow_interpreted_subclasseserrorinherits_python enter_methodr2 add_argumentrqrGselfr"r%addr#NEQadd_bool_branchactivate_blockr(gen_method_call)r[rgetattrrUrrX error_baseattr_arggeneric_getattr_resultreturn_generic call_getattrnull got_genericgetattr_results r`generate_getattr_wrapperr~s$ <<+ %D  " "499 -B <401'222s *D+GG'c |jdz}|jj|j}|j}d|jd}|j r|j |dz||jr|j |dz||j||td5|jdt}|jd t}tt} } td t|} |jt|| tj |} |j#| | | |j%| |jj'd } | r | j(nd }|d uxr|j*j-d  }|r%|j/|j1d |gd |n(|j3t4|j1|| g||jt7td t||j%| |j/|j1|j||gd ||jt7td t|d d d y #1swYy xYw)a Generate a wrapper function for __setattr__ that can be put into the tp_setattro slot. The wrapper takes two arguments besides self - attribute name and the new value. Returns 0 on success and -1 on failure. Restrictions are similar to the __getattr__ wrapper above. The wrapper calls the user-defined __setattr__ when the value to set is not NULL. When it's NULL, this means that the call to tp_setattro comes from a del statement, so it calls __delattr__ instead. If __delattr__ is not overridden in the native class, this will call the base implementation in object which doesn't work without __dict__. rz&"__setattr__" not supported in class "rrrTrrvaluer __delattr__N builtins.)rUrPrrrXrrrrr/rr2r"r%rr#EQrrrnodern startswithrrrqrHr()r[rsetattrrUrrXrr value_arg call_delattr call_setattrr is_delattrdelattr_symboldelattrdelattr_overrides r`generate_setattr_wrapperrs" <<+ %D  " "499 -B <?|,  x>SUY[_` F71&67>?5@@@s *GJJ c |j}|jj|j}|jj ||j j }t|||||\}}|jj|t||rx|jjd\}}}|j|j} |j| d|j} |j!t"| |j%|g|j} t'||| } |j(j*t,k(r;|j/d|j} |j1| | g|j} nW|j(j*t2k(r:|j/d|j}|j1|| g|j} |j!t4| |j%|| g|j|j6r"||j8vsJ|df|j8|<nA||j:vr3||j8vsJ|j8|\}}||f|j8|<||j<|j(j<|j>ddD]}||j@vs|dk7stC|j@|jD|j@|jDrStG||j@|jD||||}||jH||f<|jj||jJr\tG||jD||||d}||jH||j(jf<|jj||jd k(rtM|||y|jd k(rtO|||y|jd k(rl|jjQd }|r1|jRr%|jRjjUd r|jWd |jyyy)Nri__dict__builtins.classmethodbuiltins.staticmethodr{__init__T do_py_ops __getattr__ __setattr__rrz{"__delattr__" supported only in classes that also override "__setattr__", or inherit from a native class that overrides it.),rUrPrrrQrRrSrTrtrurrn rpartitionload_native_type_object py_get_attrrX primitive_oprIrsrldeclrrload_module_attr_by_fullnamepy_callrrJ is_property properties prop_settersmethodsmrorrLr]gen_glue glue_methodsrrrrrrr)r[rr\rUclass_irr]r^r_rr type_dictrxrwcls_meth stat_meth getter_irbasefrs r`handle_ext_methodrs 99D~~((3H .. $ $T7??+P+P QC%gtT3EGX W%GT"]]--c2 1d--dmm<''ZC (( Y(8(8(>? -WdIF <<   0 0;;rN)rUr)rrs r`rzgen_func_ns..qsD  99j0 tRC$//4IJsAA)joinfn_infos)r[s r`rros& 88$$ rbct||s|S|j|}|}t|D]R}|j|j}t |t sJ||j||g|j}T|S)zApply decorators to a function. Given a decorated FuncDef and an instance of the callable class representing that FuncDef, apply the corresponding decorator functions on that decorated FuncDef and return the decorated function. ) rrmreversedrevisitorr}r,rrX)r[r\ orig_func_reg decoratorsr_d decorators r`rlrlxs  &,,T2JH j !IHHW__- )U+6Y6+??9xj(--HI Orbc||jvSrO)rm)r[r\s r`rrs 7.. ..rbrc |jrt||||||j|S|r9|jj t rt ||||||jSt||||||j|S)ayGenerate glue methods that mediate between different method types in subclasses. Works on both properties and methods. See gen_glue_methods below for more details. If do_py_ops is True, then the glue methods should use generic C API operations instead of direct calls, to enable generating "shadow" glue methods that work with interpreted subclasses. )rgen_glue_propertyrXrUrrgen_glue_property_settergen_glue_method)r[base_sigtargetclsrr\rs r`rrsq&  (FCtyyR[\\V[[++N;'63diiXX 7Hfc4I VVrbc,eZdZUded<ded<ded<y)ArgInfoz list[Value]rzlist[str | None] arg_namesz list[ArgKind] arg_kindsN)__name__ __module__ __qualname____annotations__rbr`r9r9s rbr9c |Dcgc]#}t|j|jf%}}|Dcgc])\}}|j|j ||d|+}}}|Dcgc]P}|j j s&|j jr|js |jndR}}|Dcgc]}|j } }t||| Scc}wcc}}wcc}wcc}w)NT)is_arg) rrUrread add_local_regris_named is_optionalpos_onlyr9) r[rt_argsrXr fake_varsvarrrr:r;s r`get_argsrKs6=>s#chh-*>I>#  C  W**3T*BDI D   HH%%'CHH,@,@,B3<<^bbI&--c-I- 4I ..? .s(C&.C+)AC1C6c 0t|||jj||j|j|j d<t |j}|jjtk(r/t|jdjt||d<t|||}|j|j|j} } } d} |j r]| d|j } | d|j } | d|j } t |j"j|j d} t%d| Dr2t%d|jjjDrd}|rv|jjt&k(r|j"j)|} d}n| d} d}|j"j+| |j| |d|| |d| |d}n+|j"j-|j| | | || }|j/||j|}|j1t3||j5\}}}}}|j r|d|j }t7t9|jd z|jzd z|j|j:t=|||jj|jj> ||S) aUGenerate glue methods that mediate between different method types in subclasses. For example, if we have: class A: def f(builder: IRBuilder, x: int) -> object: ... then it is totally permissible to have a subclass class B(A): def f(builder: IRBuilder, x: object) -> int: ... since '(object) -> int' is a subtype of '(int) -> object' by the usual contra/co-variant function subtyping rules. The trickiness here is that int and object have different runtime representations in mypyc, so A.f and B.f have different signatures at the native C level. To deal with this, we need to generate glue methods that mediate between the different versions by coercing the arguments and return values. If do_pycall is True, then make the call using the C API instead of a native call. rjrNc3<K|]}|jywrO)is_star)rrs r`rz"gen_glue_method..s 0d4<<> 0rc3RK|]}|jj !ywrO)rrN)rrs r`rz"gen_glue_method..s%9#&CHH   9s%'Tr{) bitmap_args___glue)r) check_native_overrider r]rr ret_typeslistrrrr!rUr-rKr;r:num_bitmap_argsr[rrget_native_typepy_method_callcallcoercerr(rrrrr r)r[r5r6r7rrX do_pycallrHarg_inforr;r:rPfirststretvalarg_regsrrrs r`r4r4sD'8V[[__dC MMO$--Gb8==!G {{;& a 0 5 5y~F $/H!)0B0BHDVDVY)DK/x///09!9!9 9: 9!9!9 9: 7??//1I1I0I0KLM  0i 00S9*0++//*>*>96  ;;  0 0OO33C8EBGEB// 6;;RS 42323 %% KKy)T{& ^^FH$5$5t V>V ,(--(^_` == & &',,*D*D w||< 1',,'? bQRrbc |jttt|}|j |}|j ||} |j |jd<|r|j| |j|} n&|jt| |j|} |j| |j |} |jt| |j\} } }}} tt!|jdz|jzdz|j|j"t%|g|| |S)aGenerate glue methods for properties that mediate between different subclass types. Similarly to methods, properties of derived types can be covariantly subtyped. Thus, properties also require glue. However, this only requires the return type to change. Further, instead of a method call, an attribute get is performed. If do_pygetattr is True, then get the attribute using the Python C API instead of a native call. rjrQrR)rr!rr-add_self_to_envrCrrTr rUrr$rZr(rrrrr )r[r]r6r7rrX do_pygetattrrt_arg self_targetrr_retboxrrr return_types r`r2r2=s$ MMO  9S> 2F))#.K ,,{D )CLLGb$$S&++t<WS&++t<= ^^FCLL$ 7F KKv&-mmo#D!V[!  KK$  *W 4 HH    6(K 0    rbc v|j|j|jd<t|j}t |jdj t||d<t|||}|j}|d} |d} |j jtsJ|j ttd} |jt| |j| |j| t |g||j|j#|j|} |j%t'| |j)\} }}}}t+t-|j dz|j zdz|j |j.t1||| |S)a Generate a shadow glue method for a property setter. For interpreted subclasses, property setters can't be called via the internal __mypyc_setter__ method. Instead, use Python's setattr to set the property via the standard descriptor protocol. rjrr{NrQrR)rrrTrUrr!rUr-rKrrlenr rJrsrZr2nonerr(rrrrr )r[r]r6r7rrXrHr\rself_argr prop_namer_r`rrros r`r3r3is{ MMOLLGb388nGCHHQK,,in=GAJ$/H ==DAwHQI ;; ! !. 11 1 C/12I     Y ' NN9&7 > ^^GLLNCLL$ ?F KKv*1--/'Haa  KK$  *W 4 HH    '; /    rbct|}||ur|j|S|jjs|jjr|j|S|j |t S)zGiven a FuncDef, return the target for the instance of its callable class. If the function was not already defined somewhere, then define it and add it to the current environment. )rClookuprrrrDr2)r[r\ target_symbols r`rWrWsa +40MD ~~m,,##w'N'N~~d##  '8 99rbc||jjvr6|jj|}|jj|}|S|j |j |x}r|}|St |trO|jjd}|j|d|}|ddD]}|j|||}|S|j|j|}|S)Nrirr{) rPrr[rW load_builtinrnr}rrUrorpr ) r[runbounded_typerXr class_objbuiltin path_partsrs r` load_typer~s gnn'''>>,,S1OO33H=  ((t< < <   NK 0#((..s3 ++JqM4@ qrN CD++ItTBI C ++CHHd; rbc|rU|j|js:|jdd}|j|}|j |||}|S|j ||}|S)Nrir)rcurrent_modulersplit load_moduler rp)r[rrnrXmodule loaded_modulerks r` load_funcrsq++G,B,BC %a(++F3 ""=)TB K&&y$7 Krbc|j}|jj|}t||jj |}|j }|jj|j d|}|jj|dt|}ttt} } } |jt||g|} |j| |jd|} t!t"}|j%| | | |j'| |j)|| ||j+| |j'| |j-d|}t/|||}|j1|||g|}|j3t4|||g||j)||||j+| |j'| t7|||||y)Nrdispatch_cachezis notzfunctools._find_impl)rXrPrrKr]rrr[get_type_of_objget_attrr0r"r rDtranslate_is_op none_objectr'r2rrrVgotorload_singledispatch_registryrrqrFgen_calls_to_correct_impl)r[!main_singledispatch_function_namerrXcurrent_func_declr\dispatch_func_objrrcall_find_impl use_cache call_func get_result is_not_none impl_to_use find_implregistry uncached_impls r`)generate_singledispatch_dispatch_functionrs ::D33E:!2!6!6!;!;TBH ..x}}Q/?FH__--+_dN,6<z|yIN%%&?.RZA[]abJ))*g6I6I6KXW[\K,-K KNC 9% NN; D1 LL >*445KTRI+G5FMHOOI(/CTJM NN)NHm+TVZ[ NN; t4 LL 9%g{HeTJrbcjj|dfd }jd}|sJjj ||}t t } }j ||| j|jt|t} t|} | jD]{\} } t t }}j| }j| |d}j |||j||| j|}jtj| j!|j"j$j&}j)|j*j,}jt/|y)Nc4jj|}jj|jj j }j|jj}jt|yrO) rPrr[rYrr;r:rZr]rrr()r\rret_valcoercedr\r[rrXs r`gen_native_func_call_and_returnzBgen_calls_to_correct_impl..gen_native_func_call_and_returnswNN//5 //&& x}}h&8&8(:L:Ld ..*;*?*?*H*H$O F7O$rbz builtins.intz==)r\r returnNone)rPrryr[ type_is_opr"rrrr*r1get_native_impl_idsitemsload_int binary_opr+rrr;r:rZr]rr()r[rr\rrXr int_type_objis_int native_callnon_native_call passed_id native_idsrdi call_impl next_impl current_idcondrrrs` ` ` @r`rrs 33E:%%''=L < __ ' ' \4 HF#-<K FKA ;' E+~tDEI$We4J##% *a)|Z\9 %%a(   JdCi; y)'-y) * KK  ?+ooX]]D(*<*P>PGnnW&7&;&;&D&DdKG KKw rbc|jt||t|t|jj j jd<t|jj j jd<d|jj j _d|jj j _ t|t||||j\}}}}}t|||||} |jj| t!||t#||t%||} t'||| j(|} | | fS)zCreate a dispatch function (a function that checks the first argument type and dispatches to the correct implementation) rrT)rr:r9r0rcallable_classr attributeshas_dictneeds_getseters+generate_singledispatch_callable_class_ctorrrr6rtrur7%add_register_method_to_callable_classr8&generate_dispatch_glue_native_functionr ) r[rmain_func_name dispatch_namer]rrrrdispatch_callable_classr_dispatch_func_irs r`rr,s,  MM(5-01!?NGOO""%%00> & &u -D5H  hmm +D!H$6$66I""I Qoo""#6iTXYG KKw &-mmo#HaG $& ))rbc T|jjj}|jjj}|j |dt 5|jtg|}|jt|jd|||jtg|}|jd}|jt|j||g||jtt!dt ||dddy#1swYyxYw)zGCreate an __init__ that sets registry and dispatch_cache to empty dictsrrrr{N)rrrXrrrr.rqrErr)rrsr rJr(r%)r[rXr empty_dict cache_dictdispatch_cache_strs r`rr[s ?? % %D--00H   h O DE^^KT:  GGLLNJ DIJ^^KT: $--.>?]W\\^=OQ[,\^bc F71ot>@= 5#( = M4}I&--m< == :"6uzzB!'>5>>4P $AABSUYZ114F 3V2WY]^ #33EJJE -w/?/? /K][]a '2&7&7&9I"U)2EF  "!'5::u~~tLI#E*J&z3DEL L1I% (--/B/K/KT 09JDQ ]C#GS$=K NN1Hk93UW[ \ ]!11 /$  T4H+Irbc |j|}t|Dcic]\}\}}t||r||c}}}Scc}}}w)zgReturn a dict of registered implementation to native implementation ID for all implementations )r enumerater)r[rrrrrds r`rrsG  ( ()< =E*3E*: ^ ^;C,wX\B]D!G ^^ ^s AAc|j}|j||jd|jjdj }|j xsd}|sN|jj|||jj|}|jt||n|jt|j\}} } } } t||| S)zGenerate an implicit trivial property getter for an attribute. These are used if an attribute can also be accessed as a property. rrrj)rUrrr]rr_liner[rrrr(r+rr) r[rris_traitrUself_regrXrrrrrrs r`gen_property_getter_irrs >>D MM$##FIMM,>,>q,A,F,FGH ?? bD ((49O9OQUV F5$'( KM")0&D!VXw )T6 **rbcR|j}|j||jd|jjdj }|jd|jjdj }|j tsJ|ttd}|jxsd}|s|jt|||||jt|j||j\} } } } } t|| | |S)zGenerate an implicit trivial property setter for an attribute. These are used if an attribute can also be accessed as a property. rrrr{Nrj)rUrrr]rrrrrqrrr)r(rrrr)r[rrrrUr value_reg attr_namerXrrrrrs r`gen_property_setter_irrs >>D MM$##FIMM,>,>q,A,F,FGH$$Wimm.@.@.C.H.HII ??> ** *S(*+I ?? bD  GHiDAB KKw||~t,-)0&D!VXw )T64 00rb)r[r3r\r rr)r[r3rfrrr)r[r3rvr rr)r[r3rr rr,)NF)r[r3rr rUstrr]r rClassDef | Nonerboolrtuple[FuncIR, Value | None]) r[r3r]r rrrrrr)r[r3rr rr)F)r[r3rzlist[Register]rzlist[BasicBlock]r]r rr:rrrrrr)r[r3rrrr rr)r[r3rrrr rr)r[r3rrr\r rr) r[r3r!rrrr\r rr)r[r3rr)r[r3r\r r,r,rr,)r[r3r\r rr)r[r3r5r r6rr7rrrr\r rrrr)r[r3rHzSequence[RuntimeArg]rXintrr9)r[r3r5r r6rr7rrrrXrr[rrr) r[r3r5r rfr rXrrr)r[r3r]r r6rr7rrrrXrrkrrr)r[r3r]r r6rr7rrrrXrrr)r[r3r\r rrB) r[r3rrrzz Type | NonerXrrr,) r[r3rrrnz str | NonerXrrr,)r[r3rrrr rr) r[r3rr,r\r9rr rXrrr) r[r3rr rrrrr]r rztuple[FuncIR, Value]) r[r3rr rrrrrr)r[r3rr)r[r3rr:rr)r[r3rr,rXrrr,)rrrr)r[r3rr rr)r[r3rr rzdict[FuncDef, int]) r[r3rrrrrrrr)__doc__ __future__r collectionsrcollections.abcrtypingr mypy.nodesrrr r r r r rrr mypy.typesrrrr mypyc.commonrrrrmypyc.ir.class_irrrmypyc.ir.func_irrrrrrr r! mypyc.ir.opsr"r#r$r%r&r'r(r)r*r+r,mypyc.ir.rtypesr-r.r/r0r1r2mypyc.irbuild.builderr3r4r5mypyc.irbuild.callable_classr6r7r8r9mypyc.irbuild.contextr:r;mypyc.irbuild.env_classr<r=r>r?mypyc.irbuild.generatorr@rAmypyc.irbuild.targetsrBmypyc.irbuild.utilrCmypyc.primitives.dict_opsrDrErFmypyc.primitives.generic_opsrGrHrIrJmypyc.primitives.misc_opsrKmypyc.sametyperLrMrargryrrTrrrrrrr#rrlrrr9rKr4rSr2r3rWr~rrrrrrrrrrYrrrr@rbr`rs ##$   HGLL6    VU ; P25  8A - &>>!! v v v v  v  v  v!vr *2AVZ 2 *).. . . .  .  .  ."&.!.b/2d0@faH%* %*!0%*8@%*HO%* %*P,/W WW W  W  W  WW W4j /\ \\ \  \  \  \\ \~ "/:GOR :) ) ) )  )  )  )) )X/ /*/4:/AH/PW/_b/ /d:":  K  K;> KGN K  KF-! -!%*-!6=-!FM-!UX-! -!`& &&&8;&LO&Vc&&8* *&*=E*VY* *& E+ZA.Ib_+ +#++3;+GK+ +(1 1#+13;1GK1 1rb