pPj2NUdZddlmZddlmZmZmZddlmZddl m Z m Z m Z ddl mZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6dd l7m8Z8dd l9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEdd lFmGZGmHZHdd lImJZJmKZKdd lLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYddlZm[Z[ddl\m]Z]ddl^m_Z_m`Z`ddlambZbmcZcmdZdmeZemfZfddlgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZmZddlmZddlmZddlmZmZmZmZddlmZddlmZddlmZmZmZmZmZddlmZmZmZddlmZddlmZddlmZmZdd lmZmZmZdd!lmZmZmZmZdd"lmZmZmZmZmZmZmZdd#lmZmZdd$lmZhd%Zd&ed'<Gd(d)eJeeKd*ZGd+d,eԫZeezZGd-d.Zd:d/Zd;d0Zdd7Z d?d8Z d@d9Zy*)AzrBuilder class to transform a mypy AST to the IR form. See the docstring of class IRBuilder for more information. ) annotations)CallableIteratorSequence)contextmanager)AnyFinaloverload)Graph)map_instance_to_supertype)% ARG_NAMEDARG_POSGDEFLDEFPARAM_SPEC_KIND TYPE_VAR_KINDTYPE_VAR_TUPLE_KINDArgKindAssignmentExpr AwaitExprCallExpr DecoratorDictionaryComprehension ExpressionFuncDefFuncItem GeneratorExpr IndexExprIntExpr LambdaExprLvalue MemberExprMypyFileNameExprOpExprOverloadedFuncDefRefExprStarExpr Statement SymbolNode TupleExpr TypeAliasTypeInfo TypeParamVar YieldExpr YieldFromExpr)TraverserVisitor) AnyType DeletedTypeInstance ProperType TupleTypeType TypedDictType TypeOfAnyTypeVarLikeTypeUninhabitedType UnionTypeget_proper_type) module_prefix split_target)ExpressionVisitorStatementVisitor) BITMAP_BITS EXT_SUFFIXGENERATOR_ATTRIBUTE_PREFIXIS_FREE_THREADEDKEEP_ALIVE_SHORT_LIVEDKEEP_ALIVE_WHOLE_EXPRESSION SELF_NAME generator_frame_attribute_prefixmodule_exec_namemodule_import_state_namemodule_init_only_namemodule_lock_api_nameshared_lib_name) catch_errors)Errors)ClassIRNonExtClassInfo)INVALID_FUNC_DEFFuncDeclFuncIR FuncSignature RuntimeArg)NAMESPACE_MODULENAMESPACE_TYPE_VARNO_TRACEBACK_LINE_NOAssign BasicBlockBranchCallCast ComparisonOpGetAttr InitStaticIntegerIntOp LoadAddress LoadGlobal LoadStatic MethodCallOpPrimitiveDescriptionRaiseStandardErrorRegisterSetAttrTupleGet UnreachableValue) RInstanceRTupleRTypeRUnionRVecbitmap_rprimitivebool_rprimitivebytes_rprimitivec_pointer_rprimitivec_pyssize_t_rprimitivedict_rprimitiveint_rprimitiveis_float_rprimitiveis_list_rprimitiveis_none_rprimitiveis_object_rprimitive is_taggedis_tuple_rprimitivenone_rprimitiveobject_pointer_rprimitiveobject_rprimitivestr_rprimitive)constant_fold_expr)FuncInfo ImplicitClass)LowLevelIRBuilder)Mapper)BaseNonlocalControlGeneratorNonlocalControlLoopNonlocalControlNonlocalControl)PreBuildVisitor)RegisterImplInfo)AssignmentTargetAssignmentTargetAttrAssignmentTargetIndexAssignmentTargetRegisterAssignmentTargetTuple)bytes_from_str get_func_def is_constant) vec_set_item)CompilerOptions)dict_get_item_opdict_set_item_op)iter_opnext_op py_setattr_op)list_get_item_int64_oplist_get_item_unsafe_op list_pop_lastto_list)check_unpack_count_opget_module_dict_opimport_cache_get_for_import_op"import_cache_replace_for_import_op import_opnative_import_is_initialized_opnative_import_op)CFunctionDescription function_ops)tuple_get_item_unsafe_op>!===>=+-<><=r int_borrow_friendly_opc eZdZy) IRVisitorN__name__ __module__ __qualname__Z/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypyc/irbuild/builder.pyrrrrNc eZdZy)UnsupportedExceptionNrrrrrrrrrceZdZdZ ddZddZeddddZeddZddddZed dd Z dd Z dd Z dd Z ddZ ddZddZdddZdddZdddZdddZddZddZdddZdddZdddZdddZdddZddZddZddZ d dd Zdd!Zdd"Z d dd#Z!dd$Z"dd%Z# d dd&Z$dd'Z%dd(Z&ddd)Z'dd*Z(dd+Z)dd,Z* dd-Z+dd.Z, d dd/Z-dd0Z.dd1Z/dd2Z0 dd3Z1dd4Z2dd5Z3dd6Z4dd7Z5dd8Z6dd9Z7 ddd: dd;Z8 d dd<Z9dd=Z:dd>Z; d dd?Z< ddd@ ddAZ= ddddB ddCZ>ddDZ?ddEZ@ ddFZA ddGZB ddHZCddIZDddJZEddKZFddLZGddMZHddNZIddOZJddPZKddQZLddRZMddSZNddTZOddUZPddVZQddWZRddXZSddYZTddZZUdd[ZVdd\ZWdd]ZX dd^ZYdd_ZZ dd`Z[ddaZ\ddbZ]de^dcdddZ_ddeZ`eaddfZbeaddgZcea d ddhZdeefddiZfddjZgdddkZh d ddlZiddmZjddnZkddoZlddpZm d ddqZnddrZoddsZp d ddtZq d dduZrddvZsddwZtddxZuddyZvddzZwdd{Zxdd|Zydd}Zzdd~Z{ddZ|ddZ}ddZ~ddZddZddZddZddZy) IRBuilderahBuilder class used to construct mypyc IR from a mypy AST. The IRBuilder class maintains IR transformation state and provides access to various helpers used to implement the transform. mypyc.irbuild.visitor.IRBuilderVisitor is used to dispatch based on mypy AST node type to code that actually does the bulk of the work. For example, expressions are transformed in mypyc.irbuild.expression and functions are transformed in mypyc.irbuild.function. Use the "accept()" method to translate individual mypy AST nodes to IR. Other methods are used to generate IR for various lower-level operations. This class wraps the lower-level LowLevelIRBuilder class, an instance of which is available through the "builder" attribute. The low-level builder class doesn't have any knowledge of the mypy AST. Wrappers for some LowLevelIRBuilder method are provided for convenience, but others can also be accessed via the "builder" attribute. See also: * The mypyc IR is defined in the mypyc.ir package. * The top-level IR transform control logic is in mypyc.irbuild.main. c t|||_|jg|_ig|_gg|_g|_g|_dg|_||_||_ ||_ ||_ g|_ g|_ t|_g|_g|_g|_t|_||_d|_|j,|_|j.|_|j0|_|j2j5|_|j8|_|j<|_|j>|_|j@|_ | |_!||_"i|_#d|_$d|_%tMtNdd|_(|jPg|_)g|_*||_+i|_,d|_-d|_.t|_/d|_0g|_1g|_2g|_3d|_4y)NTrF)5rbuilderbuilders symtables runtime_argsfunction_name_stackclass_ir_stackblock_reachable_stackcurrent_modulemappertypesgraph ret_types functionssetfunction_namesclasses final_namestype_var_namescallable_class_namesoptionslambda_counterfree_variables prop_settersencapsulating_funcs nested_funcskeys nested_fitemsfuncs_to_decoratorsfdefs_to_decoratorsmodule_import_groupscomprehension_to_fitem deleted_varssingledispatch_implsvisitorclass_body_classvarsclass_body_obj class_body_irrrTfn_infofn_infosnonlocal_controlerrorsimports can_borrowexpression_depthreassigned_in_exprexpr_has_suspendexpression_depth_stackreassigned_in_expr_stackexpr_has_suspend_stackglobals_lookup_module) selfrrrrrpbvrrrs r__init__zIRBuilder.__init__s)9  @Bt57D.0 -/37",   &(');>5&( 46)+.1e!  "00,,#&#:#:  --224#&#:#: $'$<$<!&)&@&@#,,$8! 68!,0-1 0"b9 )- 8: )+  !475 !&13#?A%24#26"rcX||_||_|jj||y)zuSet the name and path of the current module. This must be called before transforming any AST nodes. N) module_name module_pathr set_module)rrrs rrzIRBuilder.set_moduleCs( '&  [9rFrcyNr)rnoders racceptzIRBuilder.acceptLsNQrcyrr)rrs rrzIRBuilder.acceptOs/2rc|j|j5t|tr)|xjdz c_|jdk(r t ||_t||_|j}||_ |j|j}|j||j||j}||_|s|j|j|xjdzc_|jdk(r7|j|jt t#|_d|_|cdddS |j|j dddy#t$rt|j|}YwxYw#t$rY>wxYw#1swYyxYw)aTransform an expression or a statement. If can_borrow is true, prefer to generate a borrowed reference. Borrowed references are faster since they don't require reference count manipulation, but they are only safe to use in specific contexts. rscopeFN)rPline isinstancerrfind_walrus_targetsrrrrrcoerce node_typerrmflush_keep_alivesrHr)rrrold_can_borrowress rrzIRBuilder.acceptRs~  tyy ) $ +%%*%((A-.A$.GD+,>$+?KC#1!**4995%%*%((A-**499>$#78C9,;  sVA)F5AE= BF5F&3F5=#F# F5"F##F5& F2/F51F22F55F>r c>|jj||y)Nr )rr)rr r s rrzIRBuilder.flush_keep_aliveszs &&t5&9rc8|jj|Sr)radd)rops rrz IRBuilder.adds||##rc:|jj|yr)rgoto)rtargets rrzIRBuilder.gotos &!rc:|jj|yr)ractivate_blockrblocks rrzIRBuilder.activate_blocks ##E*rc:|jj|yr)rgoto_and_activaters rr zIRBuilder.goto_and_activates &&u-rc6|jjSr)rrrs rrzIRBuilder.selfs||  ""rc<|jj|||Sr)r py_get_attr)robjattrr s rr$zIRBuilder.py_get_attrs||''T488rc:|jj||Sr)rload_strrvaluer s rr(zIRBuilder.load_str||$$UD11rcL|jjt||S)zLoad bytes object from a string literal. The literal characters of BytesExpr (the characters inside b'') are stored in BytesExpr.value, whose type is 'str' not 'bytes'. Thus we perform a special conversion here. )r load_bytesrr)s rload_bytes_from_str_literalz%IRBuilder.load_bytes_from_str_literals ||&&~e'|jj||||Sr)r binary_oprr5rregr6r s rr8zIRBuilder.binary_ops||%%dD'4@@rcV|jj|||||jS)Nr)rrr)rsrc target_typer forces rrzIRBuilder.coerces&||""3 T5T__"]]rc8|jj|Sr)r none_objectrr s rr@zIRBuilder.none_object||''--rc8|jj|Sr)rnonerAs rrDzIRBuilder.none||  &&rc8|jj|Sr)rtruerAs rrGzIRBuilder.truerErc8|jj|Sr)rfalserAs rrIzIRBuilder.falses||!!$''rc:|jj||Sr)r new_list_oprvaluesr s rrKzIRBuilder.new_list_ops||''55rc:|jj||Sr)r new_set_oprLs rrOzIRBuilder.new_set_ops||&&vt44rc>|jj||||Sr)rtranslate_is_opr9s rrQzIRBuilder.translate_is_ops||++D$FFrNc@|jj|||||Sr)rpy_call)rfunction arg_valuesr  arg_kinds arg_namess rrSzIRBuilder.py_calls!||##Hj$ 9UUrc>|jj|||yr)radd_bool_branch)rr*rGrIs rrYzIRBuilder.add_bool_branchs $$UD%8rc8|jj|Sr)rload_native_type_object)rfullnames rr[z!IRBuilder.load_native_type_objects||33H==rc Z|jj||||||||jSr)rgen_method_callr)rbasenamerU result_typer rVrWs rr^zIRBuilder.gen_method_calls0||++ $ Ky)T__  rc8|jj|Sr)r load_module)rr`s rrczIRBuilder.load_modulerBrc<|jj|||Sr)rcall_c)rdescargsr s rrezIRBuilder.call_cs||""4t44rc>|jj||||Sr)r primitive_op)rrfrgr ras rrizIRBuilder.primitive_ops||((tT;GGrc@|jj|||||Sr)rint_op)rtypelhsrhsrr s rrkzIRBuilder.int_ops||""4c2t<|jj||||Sr)rcompare_tuples)rrmrnrr s rrpzIRBuilder.compare_tupless||**3R>>rc<|jj|||Sr)r builtin_len)rvalr  use_pyssize_ts rrrzIRBuilder.builtin_lens||''T=AArc:|jj||Sr)r new_tuple)ritemsr s rrvzIRBuilder.new_tuples||%%eT22rc8|jj|Sr)r debug_print)rtoprints rryzIRBuilder.debug_prints||''00rc<|jj||y)zFMake an object immortal on free-threaded builds (to avoid contention).N)rset_immortal_if_free_threaded)rvr s rr|z'IRBuilder.set_immortal_if_free_threadeds 221d;rc|j||}|jt|j||g||jj ||yr)r(rirdictrr|)rnon_extkeyrsr  key_unicodes radd_to_non_ext_dictzIRBuilder.add_to_non_ext_dictsHmmC.  *W\\;,LdS 223=rcfd|j|<tt}}tt|t}|j t t|}|j|}|jjj|j}|xr(|jjj||k(} d} d} d} | rd|j t tt|} |)|j ttt|} n#t!dt} n|j#||} | r tn|} |j%| |||| | d}| r_t't|}|j)| |j t+||j-||||j/||j)|| r| J| J|j ttt1|}|j ttt3|}|j t t4tt|dzt}|_t7|}|j9t:g|}|j=t>||j#||g|}|jA|d|}n|jC|}|j#tD|}|jG|}|j9tH|j#||||||| | ||t!|rdndtJg |}|J|j t+|||n| J|j9tL| g|}| s|j9tN||g||jQ||S)z=Import a module and return it for a same-group native import.N namespacer)r  __internal__file__r ))rr]rhrrYrrfrzis_native_moduler group_mapgetrrLrgrNrdr(check_if_module_loadedrmrr\ get_modulerrMrKrrOrerrirr$r@rDis_package_modulerr{rrr )rmoduler  needs_importout module_static module_cacher group_nameis_same_group_native module_id import_statemodule_lock_apialready_loadedresultinit_only_func exec_funcmodule_internal_staticshared_lib_mod_namemod_dictshared_lib_objshared_lib_file ext_suffixis_pkgr*s r gen_importzIRBuilder.gen_importsw# V&L*,c "#4fHXY xx ,@- PQ 008[[**..t/?/?@ /cDKK4I4I4M4Mf4UYc4c"& %) (, 8802J62RSL%"&((35I*5UV##*!-A"B fd3I)=3 ## |T< #' /d;F    / HHVFDOOFD$A4H I IIcN L) + ++". ..!XX/1Fv1NON,@BRSYBZ![\I%)XX-)6L+@L\& "%&5j&A#;;'92tD!%!2!2$x?RTX1Y&Z\`"#'"2"2>:t"T"&"2"24"8z48J++F3FKK MM&$/"*  ##AQ0FG E % %% HHVFE40 1( ((KK I;=E# KK:\5Y3Z\`aarcx|j||}||n|j||}|j|||S)zLook up an attribute of a module without storing it in the local namespace. For example, get_module_attr('typing', 'TypedDict', line) results in the value of 'typing.TypedDict'. Import the module if needed. )rrr$)rrr&r imported module_objs rget_module_attrzIRBuilder.get_module_attrsA??640!)!5X4??6SW;X  D$77rc btt}}|jt|||tj||j ||jt ||j ||j|||j||j |y)z:If target is NULL, assign value produced by get_val to it.N) r]rr^IS_ERRORrr\rrlr)rrget_valr  error_block body_blocks rassign_if_nullzIRBuilder.assign_if_nulls|",, Z   Z$OP K(  GIv{{D I4PQ * J'rc tt}}|jt|jjd|t zz t d|t dz zzttj|}|jt|t dttj|}|jt|||tj|j||jt||j!||j"||j%||j|y)Nr r)r]rkrwrrgrCrdreANDrraEQr^BOOLrr\rrlr) rrrindexr rrobs rassign_if_bitmap_unsetz IRBuilder.assign_if_bitmap_unsets#-, Z KK  LL  b5K#77 8 A%;?346G H II    HH\!WQ0A%BLOOUYZ [ ; FKK@A K(  GIv{{D IJK * J'rct|jdst|jdr|jy|j yNr)rrradd_implicit_returnadd_implicit_unreachabler"s rmaybe_add_implicit_returnz#IRBuilder.maybe_add_implicit_returns= dnnR0 15I$..Y[J\5]  $ $ &  ) ) +rc@|jjd}|jsy|jjj }|j |jj|jd|}|jdj|||yyr) rblocks terminatedrfitemr rrDrr gen_return)rrr retvals rrzIRBuilder.add_implicit_returns~ ##B'<<%%**D[[!2!2!4dnnR6H$OF  ! !" % 0 0vt D rc|jjd}|js|jt yyr)rrrrrprs rrz"IRBuilder.add_implicit_unreachables2 ##B' HH[] # rcn|D]}t|tst|jts/t|jjt sT|jj|j j}t|ts|jr|jd|y)Nz;Only class variables defined as ClassVar can be assigned to) r r"exprr'rr-r`r/ is_classvarerror)rlvaluesr lvaluevars rdisallow_class_assignmentsz$IRBuilder.disallow_class_assignmentss  dF6:.v{{G4v{{//:kk&&v{{388c3'JJ\^bc drc2t|jdkSN)lenrr"s rnon_function_scopezIRBuilder.non_function_scopes4==!Q&&rcB|jry|jdSr)rrr"s rtop_level_fn_infozIRBuilder.top_level_fn_infos  " " $}}Qr) type_overridect|tsJ|t|jtsJ|j|jj| |j }n|d|j }|Jd|j ||xs|j||j}|jj||jf|jt|||jyy)N.zFull name not set for variable)r r$rr/ final_valuer`rrr rappendrlrrcr)rr rvalue_reg class_namerr`coerceds rinit_final_staticzIRBuilder.init_final_statics&(+3V3+&++s+8V[[8+ ;; " " *!{{$Qv{{m4# E%E E#kk*m.Ut~~f?UW]WbWbcG    # #T7<<$8 9 HHZt/?/?@ A +rc t|j|}|J|\}}|jj||||d|dS)Nzvalue for final name "z " was not set)r  error_msg)r@rrload_static_checked)rr\typr  error_name split_namerr`s rload_final_staticzIRBuilder.load_final_statics]"$**h7 %%%! ||//   .zl-H 0  rc|dzt|z}|jj||jt |||j t yN___r)strrrrrcrrZ)rr*r`r  unique_names r init_type_varzIRBuilder.init_type_varsFUlSY.  "";/ E;0@0@L^_`rc |jtt|dzt|z|jt Sr)rrhrrrrZrr`r s r load_type_varzIRBuilder.load_type_vars:xx !u s4y(  ,    rc&t|tr$|r|j|S|j|St|tr|j j |St|tr|j j|St|tr|j j|St|tr|j j|St|tr|j j|SJd)zQLoad value of a final name, class-level attribute, or constant folded expression.zUnsupported literal value)r boolrGrIintrr0floatr2rr(bytesr-complex load_complex)rrsr s rload_literal_valuezIRBuilder.load_literal_values c4 yy&zz$'' S !<<((- - U #<<**3/ / S !<<((- - U #<<**3/ / W %<<,,S1 1 55 55r)for_readcN|dk(r |j}t|tr!|j}t|tt zr t |}|#|jsJt|j}|s.t|tr|jr|jd||jtk(r.||jdvr t|tr6t|jt s|j#|j}n|j%|}|j&j(r|j*r||j,vrr|j/|r.|j1|||j&j2dt4S|j7|||j&j2j8dS|j;||S|j=|S|jt>k(r8|jA}|jC|j|}tE||SJ|jt|tFrB|jI|jJ}|jI|jL} tE|| St|tNrF|jQ|} |jI|jR| } tU| |j| St|tVrvd} g} tY|jZD]N\}}|j]|}| j_|t|t`s9| |jd||} Ptc| | St|t`r|j]|jRSJd|z) Nrz2Cannot assign to the first argument of classmethodF)reassignprefix)rrz%Two starred expressions in assignmentUnsupported lvalue: %r)2r r r$rrr&ris_special_formr/r`is_clsrkindrrrlr4 type_to_rtyperr is_generator error_overlapris_captured_by_nested_funcadd_var_to_env_classgenerator_classrEadd_var_to_generator_frameself_reg add_local_reglookuprload_globals_dictr(rrrr_rr"is_native_attr_refrrr+ enumeraterwget_assignment_targetrr(r)rrr rsymbolreg_type globals_dictr`r_rrr%star_idxridxitemtargs rrzIRBuilder.get_assignment_target's 2:;;D fh '[[F&).?"?@%f-~----V[[) 63 7FMM OQUV{{d"!33!&#.z&++{7[#'#5#5fkk#B#'>>  11$22"d&7&77::6B#'#<#< & ( $ < <).'A $=$ $>>"Hdll.J.J.S.S^c ?  --fh?? ;;v..$#557 }}V[[$7,\4@@)fkk)u  *;;v{{+DKK -E(u5 5  +008J++fkkj+AC'V[[ZP P  *#'HG&v||4 # T11$7t$dH-+ #JDQ"H  #)(; ;  )--fkk: :7.77ur)rallow_error_valuec t|tr|St|tr |jSt|trS|j |j d|jg|j|}||SJ|j jt|trt|jjtrm|jjjjrC|xr |j}|jt!|j|j"|||S|j%|j|j"|SJd|z)N __getitem__)borrowrr)r rqrregisterrr^r_rrlrr%rrclass_ir is_ext_classrrrbr&r$)rrr rrregrs rreadzIRBuilder.readxs fe $M f6 7?? " f3 4&& ]V\\NFKKC *&++** *5 f2 3&**//95&**//:R:R:_:_#9(9(9xx  %*; '' FKKFF7.77urc t|tr8|jt||j ||j ||yt|t rD|j ||j |}|jt|j||yt|trYt|jtr|jjjd}|rm|j|j|}|jj!|}t#|j$|j&||g|}|j|y|j ||j |}|jt)|j$|j||y|j|j|}|jj!|}|j+t,|j$||g|yt|t.rt|j0j t2r.t5|j|j0|j6||y|j9|j0d|j6|gd|}|J|j0j yt|t:rt|j t<r|j>|j j@} tC| tC|jDk(sJtGtC| D]>} |jtI|| |} |jK|jD| | |@ytM|j stO|j r |j>|jQ|||y|jS|||yJd)N __setattr__ __setitem__zUnsupported assignment target)*r rmrr\ coerce_rvaluerlrrrobj_typerrr get_methodr(r&rboxrir%r`rnrirrr_rvrrr^rrsrrrrwrangeroassignrrprocess_sequence_assignment!process_iterator_tuple_assignment) rrrr setattrr boxed_regcall target_reg2rtypesi item_values rr'zIRBuilder.assigns fh ' HHVFD$6$6z6;;PT$UW[\ ]  8 9++J TJJ HHVFOOZ> ?  4 5&//95 //22==mL-- T:C $ 0 0 rr?post_star_vals iter_list iter_list_len post_star_len conditionextras rr)z+IRBuilder.process_iterator_tuple_assignments$$WzlDA(.'BFOOFLLHY \\*9- ,EKK(T:E$.L*,K HHVE;&//J K    , HH"&224QSW  HH[] #    ) KKud + ,$ ?? &#\\)a-/:N))'H:tDI ,,Y=M#C$78M}mT4PI$.L*,K HHVIxfkkJ K    , HH"&224QSW  HH[] #    )!.1 0))-)dK E5$/ 0 KK V__5y$ G KK(T:E$.L*,K HHVE8[&//J K    , HH"&224OQU  HH[] #    )rcj|jjt|jd||yr)rrr)rcontinue_block break_blocks rpush_loop_stackzIRBuilder.push_loop_stackLs- $$  5 5b 9>; W rc8|jjyr)rpopr"s rpop_loop_stackzIRBuilder.pop_loop_stackQs !!#rct|tr|St|j}|j||t|S)z1Return an assignable register containing a value.)r rmrlr'r[)rr*rs rensure_registerzIRBuilder.ensure_registerTs7 eX &Luzz" C 45 rcBt||}t|tr|SdSr)rr r)refoldeds r extract_intzIRBuilder.extract_int^s"#D!,#FC0v:d:rc>|j|j|Sr)get_sequence_type_from_typerrrs rget_sequence_typezIRBuilder.get_sequence_typebs// 40@AArc0t|}t|trz8IRBuilder.get_sequence_type_from_type..{s 'ZD (A(A$(G'Zs%(r )r>r r=rumake_simplified_unionrwrYr5rlr\rryrrg IndexError ValueErrorr; upper_boundr7listrfromkeysrrP)rr=rrwr.s` rrYz%IRBuilder.get_sequence_type_from_typeesn%k2 k9 -//DODUDUVD11$7V  X .((N:%%!!**.>>'' X))+*:*:1*=>> _ 533K4K4KL L  Y /%%E GG G5$--'ZTY'ZZ[F6{azz|#33F;;!k!u/W X K?2K!LMSWW XsE7(E<<Fc>|j|j|S)zpFind dict type of a dict-like expression. This is useful for dict subclasses like SymbolTable. )get_dict_base_type_from_typerrZs rget_dict_base_typezIRBuilder.get_dict_base_types 00D1ABBrc t|}t|tr2|jDcgc]}|j |D]}|c}}St|t r|j |j St|tr3|j}td|jjD}nAt|tr'td|jjD}n Jd|t||gScc}}w)Nc3@K|]}|jdk(s|yw)ztyping.MappingNr\r_r_s rr`z9IRBuilder.get_dict_base_type_from_type..s!JZ9Zc3@K|]}|jdk(s|yw)z builtins.dictNrlrms rr`z9IRBuilder.get_dict_base_type_from_type..s /9Yrnz!Failed to extract dict base from )r>r r=rwrhr;rdr9fallbacknextrlmror5r )rr=rinner dict_bases rrhz&IRBuilder.get_dict_base_type_from_types%k2 k9 -(--!>>tD  k? 344[5L5LM M k= 1%..K!,!1!1!5!5I X .!,!1!1!5!5I L=k]K K5)+yABB-sD c|j|}|Dcgc] }|j|jd"}}tj|Scc}w)Nrrirrgrurarrdict_base_typestr.s rget_dict_key_typezIRBuilder.get_dict_key_typeO11$79HIA$$$QVVAY/II++F33J%Ac|j|}|Dcgc] }|j|jd"}}tj|Scc}w)Nr rvrws rget_dict_value_typezIRBuilder.get_dict_value_typer{r|c`|j|}|j|}t||gSr)rzr~rs)rrkey_type value_types rget_dict_item_typezIRBuilder.get_dict_item_types2))$/--d3 x,--rc||jvrttj}nt |j|}|j |j jj}|jd|gg|d}ddl m }t|tr&t}|jD] }|||} |S|jd|gg|dS)zrr type_checker expr_checkercheck_method_call_by_name mypy.joinrr r7r<rw)rriterableechkrCrjoinedrs r_analyze_iterable_item_typez%IRBuilder._analyze_iterable_item_types tzz !#*9+?+?#@H&tzz$'78Hzz$**+88:GG11*hBPTUVWX( h **,F  2#FD1 2M11*hBPTUVWX Xrc8|jj|S)z*Is the given module one compiled by mypyc?)rrrrs rrzIRBuilder.is_native_modules{{++F33rc|jjj||jjj|jk(S)a<Is the given module in the same compilation group as the current module? Modules in the same group share a compiled C extension and can reference each other's C-level symbols directly. Modules in separate groups (separate compilation mode) must use the Python import system instead. )rrrrrs ris_same_group_modulezIRBuilder.is_same_group_modules?{{$$((0DKK4I4I4M4MdN^N^4___rc|jj|}|duxr*|jduxr|jjS)z:Is the given module a package (i.e., an __init__.py file)?N)rrtreeis_package_init_file)rrsts rrzIRBuilder.is_package_modules> ZZ^^F #~X"''"5X"'':V:V:XXrc8|jj|Sr)ris_native_ref_exprrZs rrzIRBuilder.is_native_ref_exprs{{--d33rc8|jj|Sr)ris_native_module_ref_exprrZs rrz#IRBuilder.is_native_module_ref_exprs{{44T::rcV|jxs|jxs|jduS)z:Is a type something other than just a class we've created?N)is_named_tuple is_newtypetypeddict_typerrs ris_synthetic_typezIRBuilder.is_synthetic_types(!!US^^Us7I7IQU7UUrc\d}t|jtr4t|jjtr|jjj |j }|rt|jtr|jjjdjj}|jjxs|dk(}|r?|j}|jjjd|j }|j|jjj}n|j|rdt|jtr|jjr|j}|jj}|j!|}n_|j#|}|L|}|jjd|j }|j|jj}||fSy)aCheck if `expr` is a final class, module or instance attribute. This needs to be done differently for class, module and instance attributes to correctly determine fully qualified name. Return a tuple that consists of the qualified name, the corresponding Var node, and a flag indicating whether the final name was defined in a compiled module. Return None if `expr` does not refer to a final attribute. Instance attributes only qualify if they are class-body Finals ("X: Final = ..." in the class body), which have no instance slot -- see ClassIR.class_final_attributes. Ordinary instance attributes, including "self.x: Final = ..." set in __init__, return None. Nrz enum.Enumr)r rr'rr-rr`r/basesrlr\is_finalinforris_module_member_exprrget_class_final_var) rr final_varsym expr_fullnamerr\nativers r get_final_refzIRBuilder.get_final_refs dii )j.R))..$$TYY/Cz#((C0 $  4 4Q 7 < < E E 88,,L 0L #I"%((--"8"8!99>>:JKH!22499>>3M3MNF  ' ' -$))S)dii.@.@ II 99--006**40C !hh//0#((<..sxx/C/CD  Y. .rcbt|jj|j}t |t r#|j Dcgc] }t|}}n|g}d}|D]>}t |tsy|j||j}|y|||ury|}@|Scc}w)aReturn the Var for a class-body Final read through an instance expression. Return None if `expr` isn't such a read; the caller then falls back to an ordinary attribute read, which finds these names on the type object via py_get_attr (correct, just slower). A union-typed object qualifies only when every item resolves to the same declaration, since otherwise the value differs per item. N) r>rrrr r=rwr5class_final_var_of_instancer`)rr instance_typerrwfoundrs rrzIRBuilder.get_class_final_vars( tyy(AB mY /7D7J7JKt_T*KEK"OE  DdH-224CC{ S%5E  Ls B,c|jjj|j}|y|j |}|y|\}}|jj|}|0t |j tr|j jsy|j jj|jk7ry|j S)adLook up a class-body Final attribute on a single instance type. ClassIR is the authority on which attributes were compiled as class-body Finals (mypyc.irbuild.util's is_class_body_final decides, and the answer survives serialization), so we gate on it and only use the mypy symbol table to find the defining class. N) r type_to_irrrlclass_final_attr_detailsr rr/rrr\)rinstancer`rdetails_ defining_irrs rrz%IRBuilder.class_final_var_of_instance,s;;))--hmm<  33D9 ? ;mm% ;j37sxx?P?P 88== ! ![%9%9 9xxrc|j|j|j|S|rCt|j|r-|j ||j j |||Sy)azEmit code for loading value of a final name (if possible). Args: final_var: Var corresponding to the final name fullname: its qualified name name: shorter name to show in errors native: whether the name was defined in a compiled module typ: its type line: line number where loading occurs N)rrr?rrrr)rrr\r`rrr s remit_load_finalzIRBuilder.emit_load_finalDsd  ,**9+@+@$G G  djj(;))(DKK4M4Mc4RTXZ^_ _rct|jtxr$t|jjtSr)r rr'rr#rZs rrzIRBuilder.is_module_member_exprXs'$))W-V*TYY^^X2VVrc|jr||jtgt|zk(r\t |}t j |g}|jj|||j|j|}|r|S|j}t|tr |j}t|tr<|j |j"vr$|j |j$vr |j }||jr||j&j(vrrt+d|jDrV|j&j(|}|jj-|||j|j.|jS|j1|} |j3| ||j|j|j.S)Nc38K|]}|ttfvywr)rr )r_rs rr`z3IRBuilder.call_refexpr_with_args..{sLTDWi00LsrVrW)r\rVrrget_call_target_fullnamerrrmatching_primitive_opr rrr r&implrfuncrrr func_to_declallr,rWrrS) rrcalleerUr\primitive_candidatesr callee_nodedeclrTs rcall_refexpr_with_argsz IRBuilder.call_refexpr_with_args[s ??t~~'S_1LL/7H#/#3#3Hb#A \\77$j$))T^^D=QF kk k#4 5%**K {I .  (@(@@  D$=$==%**K  #t{{777LT^^LL;;++K8D<<$$T:t~~t~~W[W`W`a a;;v&|| j$))t~~QUQ_Q_  rcdfd }jjjjfd|jS)Ncjrbjjttjdj j jjSjj S)Nz+mypyc internal error: should be unreachable) right_unreachablerrrl RUNTIME_ERRORrightr rDrrrsr handle_rightz1IRBuilder.shortcircuit_expr..handle_rightse%%   &*88E ||((**;;tzz* *rc:jjSr)rleftrsrz-IRBuilder.shortcircuit_expr..s4;;tyy3Irreturnrq)rshortcircuit_helperrrr )rrrs`` rshortcircuit_exprzIRBuilder.shortcircuit_exprsA +||// GGT^^D)+I ? JL)rcz|jj}|jj|jj}|jj}|j j}|j j|jj|_|jj|_ |jj|_ |jd|_ |j d|_|j||j ||fSr)rrPrrrrrrrrrrrrrrgr)rrrrrs rleavezIRBuilder.leaves--##% ((,,. >>%%'--##% !!# $ ; ; ? ? A"&"?"?"C"C"E $ ; ; ? ? A}}R( }}R( ||\7>>8WLLrc#K|jj|j|jjt |jd|j jg||_|jj|j |jjt|jjt d|jj|jj|j j|jj|jj|jj|jd|_|jd|_y#|jj|jj|j j|jj|jj|jj|jd|_|jd|_wxYww)aPush a lightweight scope for comprehensions. Unlike enter(), this reuses the same LowLevelIRBuilder (same basic blocks and registers) but pushes new symtable and fn_info entries so that the closure machinery sees a scope boundary. rN) rrrrrrrrrrrrrP)rrs r enter_scopezIRBuilder.enter_scopes T\\* d4>>"#567   $  T\\* o. $$%8%:; -  MM    NN      ! ! # NN   MM     ! ! % % '==,DL==,DL MM    NN      ! ! # NN   MM     ! ! % % '==,DL==,DLs C I5#F,'CI5,CI22I5c#*K|j}|j}|j}d|_ |jj |5dddd||_||_||_y#1swYxYw#||_||_||_wxYww)a^Enter new borrow scope from which borrows can't leak to outer expressions. This is a borrow region (see LowLevelIRBuilder.borrow_region) that also resets the per-expression borrowing heuristic state, since the body forms its own top-level expression context (e.g. a comprehension iteration or a lambda body). rN)rrrr borrow_region)rr old_expression_depthold_reassigned_in_exprold_expr_has_suspends renter_borrow_scopezIRBuilder.enter_borrow_scopes $44!%!8!8#44 ! 9++D1  %9D !&c%Br6"  LL   $ $S ) rc~|j||||jd|}t|tsJ||S)zALike add_local, but return an assignment target instead of value.r)rrr r)rrrrrs rr zIRBuilder.add_local_regSsB vsF+#F+&":;CVC; rcV|jttt|dS)zLow-level function that adds a 'self' argument. This is only useful if using enter() instead of enter_method(). Tr)r r/rIrr)rclss radd_self_to_envzIRBuilder.add_self_to_env\s$ !!#i.)C.!NNrc*||jd|<|Srr)rrrs r add_targetzIRBuilder.add_targetcs%+r6" rc8|jj|Srr^rs rrzIRBuilder.type_to_rtypegs{{((--rct|trtS||jvrtS|j|}|j |Sr)r rr}rrr)rr mypy_types rrzIRBuilder.node_typejsC dG $! ! tzz !$ $JJt$ !!),,rc p|j|||jj|j||||S)Nralways_definedkeep_alive_on_completionr)add_var_to_classr env_class curr_env_reg)rrr5r_rr r rs rrzIRBuilder.add_var_to_env_classssD$$   LL " "   )%=%  rc|jj|gD]>}||jj|tvry|j ||s>yy)NTF)rrrris_free_variable_in_nested_func)rrrnesteds rrz)IRBuilder.is_free_variable_in_nested_funcs\..225"= F,,00??33FFC   rc||jj|jjt vxs&|j |jj|S)z7Does a binding need to be visible to a nested function?)rrrrrrrs rrz$IRBuilder.is_captured_by_nested_funcsT,,00 LL    N  1 1$,,2D2Df M Nrc |jjj}|j|||||||t |j |j S)zDAdd a generator-owned source binding to the private generator frame.)is_final_classr)rrrr rJr\r)rrr5 frame_regrr r rs rrz$IRBuilder.add_var_to_generator_frames]ll**--$$    )%=3 S-?-?%  rc |t|jz} ||j| <|r|jj | |r|j j | t || } |rz|j|j||jjj} |j t|| | |jjj|j|| S)zNDeclare an attribute on a class and construct a target using an explicit base.)rr` attributes!attrs_to_keep_alive_on_completionrattrs_with_defaultsrrr rrr rnr) rrr5rr_rr r rr` attr_targetrs rr zIRBuilder.add_var_to_classs2388<<$t #  1 1 5 5d ;   # # ' ' -*46 ))DKK,dll.@.@.E.EFC HHWT4dll.@.@.E.EF GsK00rc|jsJdd|jjvxr+|jjjdddk(S)NRefExpr not resolvedrrbuiltins)rr\splitrZs ris_builtin_ref_exprzIRBuilder.is_builtin_ref_exprsNyy000ydii((([TYY-?-?-E-Ec-J1-MQ[-[[rc|j|rC|jsJd|j|jj|jS|j |r^t |jtrD|j|js)|jsJ|j|jS|j|j|jS)zLoads a Python-level global. This takes a NameExpr and uses its name as a key to retrieve the corresponding PyObject * from the _globals dictionary in the C-generated code. r) rrload_module_attr_by_fullnamer\r rr r-rr[load_global_strr`rZs r load_globalzIRBuilder.load_globals  # #D )99 44 4944TYY5G5GS S  * *4 0499h/**4995== =// > >##DIItyy99rcx|j}|j||}|jt||g|Sr)r r(rir)rr`r _globalsrs rr!zIRBuilder.load_global_strs:))+mmD$'  !1Hc?DIIrcv|jxs |j}|jttd|S)Nglobals)rrrrhr|rs rr zIRBuilder.load_globals_dicts0++?t/?/?xx ?IvFGGrct|jd\}}}|j|}|j|||SNr) rpartitionrcr$)rr\r rrr`rs rr z&IRBuilder.load_module_attr_by_fullnames="--c24'dD11rc|jj}t|txr@|jj xr(t fd|jjDS)zIIs expr a direct reference to a native (struct) attribute of an instance?c3NK|]}j|jvywr)r`r)r_rrs rr`z/IRBuilder.is_native_attr_ref..sP2DII.Ps"%)rrr rrrranyrrrr obj_rtypes ` rr zIRBuilder.is_native_attr_refsYNN499- y) , Q""// QP9K9K9O9OPP rc|j|j}t|txr=|jj xr%|jj |jS)a]Is expr a direct reference to a Final native (struct) attribute of an instance? A Final attribute is read-only at runtime (it has no setter), so it can never be reassigned after construction. This makes it safe to borrow even on free-threaded builds, since no concurrent store can invalidate the borrowed reference. )rrr rrrr is_final_attrr`r-s ris_final_native_attr_refz"IRBuilder.is_final_native_attr_refsVNN499- y) , <""// <""00; rc|jsy t|tr|jr |j}n*t|t r|jr |j }nnTt|tsy|jD]A}|jdj|}t|ts2|j|usAyy)aIs the root local variable a borrow chain 'v' reads from reassigned this expression? A whole-expression borrow of an attribute keeps the borrow root alive only via the register holding it. If that register belongs to a local variable that is rebound (via a walrus assignment) during the same top-level expression, the old value may be freed while the borrow is still live. FTr) rr rb is_borrowedr%r`r<rmrrrr)rr}rrs rroot_is_reassignedzIRBuilder.root_is_reassigneds&&!W%!--EEAt$EE !X&-- F^^B'++F3F&":;ST@T rc"d|jd<y)zMark statements in the innermost block being processed as unreachable. This should be called after a statement that unconditionally leaves the block, such as 'break' or 'return'. FrN)rr"s rmark_block_unreachablez IRBuilder.mark_block_unreachable"s */""2&rc.t|j|Sr)rPrrAs rrPzIRBuilder.catch_errors+sD,,d33rcR|jj||j|yr)rwarningrrmsgr s rr9zIRBuilder.warning.s C!1!148rcR|jj||j|yr)rrrr:s rrzIRBuilder.error1s #t//6rcR|jj||j|yr)rnoterr:s rr>zIRBuilder.note4s d..5rc|j|jf}||jvr|jd|dd|y|jj ||j j |y)NzDuplicate definition of "r z" not supported by mypyc)rr`rrrrr)rfunc_irr r`s r add_functionzIRBuilder.add_function7sk""GLL1 4&& & JJ247);STVZ [  % g&rc|jjj}|jjj |Sr)rrrrrr)r type_infos rget_current_class_irzIRBuilder.get_current_class_ir?s2LL&&++ {{%%)))44rc|jtt|dzd|jt t dt gt|g|jS)N_coroutine_setuprl) rr_rUrrWrXrrxr )rrr%s radd_coroutine_setup_callz"IRBuilder.add_coroutine_setup_callCs[xx !33$$!:f6G#H"I?[     rc:|jj||Sr)r load_builtinrs rrIzIRBuilder.load_builtinQs||((t44r)rrrzdict[Expression, Type]rr rrQrrrrrrrrrz%dict[FuncDef, list[RegisterImplInfo]]rNone)rrrrrrJ)rrrrrrq)rr)rrJ)rzStatement | Expressionrrr Value | None)r rr rrrJ)rrjrrq)rr]rrJ)rr]rrJ)rrm)r%rqr&rr rrrq)r)r*rr rrrq)r*rr rrrq)r*rr rrrq)r5rqr6rr rrrq) r5rqr:rqr6rr rrrq)F) r<rqr=rtr rr>rrrq)r rrrq)rM list[Value]r rrrq)NN) rTrqrUrLr rrVlist[ArgKind] | NonerWzSequence[str | None] | Nonerrq)r*rqrGr]rIr]rrJ)r\rrrq)r_rqr`rrUrLra RType | Noner rrVrMrWzlist[str | None] | Nonerrq)r`rrrq)rfrrgrLr rrrqr) rfrkrgrLr rrarNrrq) rlrtrmrqrnrqrrr rrrq) rmrqrnrqrrr rrrq)rsrqr rrtrrrq)rwrLr rrrq)rzz str | ValuerrJ)r}rqr rrrJ) rrSrrrsrqr rrrJ)rrr rrrK)rrKrrqr rrr]rr]rrKrrJ)rrr rrrq)rrr&rr rrrq)rrmrCallable[[], Value]r rrrJ) rrmrrOrrr rrrJrrJ)rz list[Lvalue]r rrrJ)rr)rzFuncInfo | None) rr!rrqr str | NonerrNrrJ) r\rrrtr rrrQrrq)r*rqr`rr rrrJ)r`rr rrrq)rsz*int | str | bytes | float | complex | boolr rrrq)rr!r rrrrr) rzValue | AssignmentTargetr rrrrrrrq)rzRegister | AssignmentTargetrrqr rrrJ)r4rqr5rtr rrrq)rrr4rqr rrrJ)r=rr>rqr rrrJ)rrrrqr rrrJ)rLr]rMr]rrJ)r*rqrrm)rUrrz int | None)rrrrt)r=r8rrt)rrrlist[Instance])r=r8rrR)rrrr8)rrrr)rr'rr)rr-rr)rr"rztuple[str, Var, bool] | None)rr"r Var | None)rr5r`rrrS)rr/r\rr`rrrrr8r rrrK)rr"rr)rrrr'rUrLrrq)rr%rrq)rzRefExpr | TupleExprrzlist[ClassIR] | None)r)rFuncInfo | strrrtrrJ)rzJtuple[list[Register], list[RuntimeArg], list[BasicBlock], RType, FuncInfo])rrrIterator[None])r rrrU)rNF)rrRr`rrrtrrTrrNrrrrU)rz str | Varrrtrrrrm)rr*r SymbolTarget)rr*rrtrrrrm)rr*rrtrrrr)rrRrr)rr*rrVrrV)rz Type | Nonerrt)rrrrt)FFFr)rr*r5rtr_zFuncInfo | ImplicitClassrrr rr rrrrr)rrrr*rr)rr*rr)FFF)rr*r5rtrrqrrr rr rrr)rr*r5rtrrRr_rqrrr rr rrrrr)rr$rrqr)r\rr rrrq)r}rqrr)r rrr)r;rr rrrJ)r@rVr rrrJ)rzClassIR | None)rrr%rqrrq)r`rr rrrK)rrr__doc__rrr rrGrrrrr rr$r(r.r0r2r4r8rr@rDrGrIrKrOrQrSrYr[r^rcrerirkrprrrvryr|rrrrrrrrrrrrrrrrrrrrr'r"r(r@r)rNrQrSrWr[rYrirhrzr~rrrrrrrrrrrrrrrrrrrrrrrrrr rr rrrrrrrrr rr"r!r r r r1r4r6rPr9rr>rArDrGrIrrrrrs+0`6`6&`6 `6  `6  `6`6`6!`6D`6 `6H:=BQQ 22IN&P+/-1        "    (  +     .5%) H"HH H " H  H=?B31< >& >-0 >7< >DG >  >]L&*AAA A ! A  A#A A8b 8((()<(EH(PS( ($, E$ d' "& B '+ BBB B $ B B*NR    "'  /2  @J    a  LN6=6EH6 6.+-O8BGO8O8$'O8;?O8 O8h"8 !"' "8("8"8  "8  "8 "8H+:Z 0-+-5:-BE- -B (% (.3 (;> (  (E*+E*9>E*FIE* E*N $;B":CC64 4 . Y,4`Y 4;V*X60(+36@DKOWZ (W) ) &-) ;F) ) V &.**4 M--<99( #%"&'&'&'& '&  '&  '&'& '&'&RHO *  >C ',6: !O.-$).   '      #'    *N$).         #'   <$).1 11 1  1  11#'11 1<\:&J H2    4/4976'5  5rrcjjd}jD]jsj j dfd }t tsJj}|jjs2jj|jjjj||jj|dz }y)zGenerate blocks for arguments that have default values. If the passed value is an error value, then assign the default value to the argument. rcjJtjrjjSjjs}j dzj jz}jj|jfjtj|jSj j}jjjjj |<jt#jjj$|j&Sr() initializerrrr is_nestedr\variabler`rrrlrrhrcallable_classrrrbrr )r`rrrrs r get_defaultz%gen_arg_defaults..get_defaultas222s/">>#//::!22 >>C/#,,2C2CCD''..fkk/BC";;z&++tWEXEX'YZZ<<,,DIOGOO2255@@F";; > > G GsxxXrr Nr)rr argumentsrZr r\r rrrlrrr r)rnbr^rrrrs` @@@rgen_arg_defaultsraUs OO ! !E B  ??^^CLL1F  (f&>? G G?//C88))&&v S__EYEYZ..OO["coo6J6JaA rc&|jddS)aMRemangle names produced by mypy when allow-redefinition-old is used and a name is used with multiple types within a single block. We only need to do this for locals, because the name is used as the name of the register; for globals, the name itself is stored in a register for the purpose of doing dict lookups. ' __redef__)replacers rrrs <<[ ))rct|jtrEt|jj}t|t r|j jS|jSr)r rr,r>rr5rlr\)refrs rrrsF#((I& 1 fh ';;'' ' <<rc4eZdZdZddZdfd ZddZxZS)WalrusTargetCollectorzCCollect the symbols assigned to by walrus expressions in a subtree.c"t|_yr)rtargetsr"s rrzWalrusTargetCollector.__init__s (+ rc|jj/|jj|jjt||yr)rrrkrsupervisit_assignment_exprrr __class__s rrnz+WalrusTargetCollector.visit_assignment_exprs8 88== $ LL  QXX]] + %a(rcyrrrrs rvisit_lambda_exprz'WalrusTargetCollector.visit_lambda_expr rrP)rrrrJrr rrJ)rrrrWrrnrs __classcell__rps@rririsM.)  rricPt}|j||jS)zReturn the symbols reassigned via a walrus expression within 'expr'. Walrus (':=') is the only way to rebind a variable in the middle of evaluating an expression, so this is the complete set of in-expression reassignments. )rirrk)r collectors rrrs$ &'IKK    rcXeZdZdZd dZd dZd dZd dZd fd Zdfd Z ddZ xZ S)SuspendDetectorz7Detect await/yield/yield from expressions in a subtree.cd|_y)NFrr"s rrzSuspendDetector.__init__s  rcd|_yNTr}rrs rvisit_await_exprz SuspendDetector.visit_await_expr  rcd|_yrr}rrs rvisit_yield_exprz SuspendDetector.visit_yield_exprrrcd|_yrr}rrs rvisit_yield_from_exprz%SuspendDetector.visit_yield_from_exprrrc\t|jrd|_t||yr)r,is_asyncrrmvisit_generator_exprros rrz$SuspendDetector.visit_generator_exprs$ qzz?DJ $Q'rc\t|jrd|_t||yr)r,rrrmvisit_dictionary_comprehensionros rrz.SuspendDetector.visit_dictionary_comprehensions" qzz?DJ .q1rcyrrrrs rrsz!SuspendDetector.visit_lambda_exprrtrrP)rrrrJ)rr0rrJ)rr1rrJ)rrrrJ)rrrrJru) rrrrWrrrrrrrsrvrws@rr{r{s)A(2  rr{cPt}|j||jS)a'Does evaluating 'expr' involve a suspension point (await/yield/yield from)? A whole-expression borrow can't safely span a suspension point, since the borrowed value and its borrow root are held in registers that aren't spilled into the generator environment across the suspend. )r{rr)rdetectors rrrs" HKK >>rc g}d}|D]=}|jtk(r|r|}ne|j|d|}|}nO|jtk(r|j|d|}n(|jtk(sJ|j|d|}|jtk7rN|j ||j |j||j|g|ttgddg}n.|j ||j |j|g|}|j||j||j|@|S)aRCreate objects representing various kinds of Python 3.12 type parameters. The "typing_mod" argument is the "_typing" module object. The type objects are looked up from it. The returned list has one item for each "type_args" item, in the same order. Each item is either a TypeVar, TypeVarTuple or ParamSpec instance. NTypeVar TypeVarTuple ParamSpecinfer_variancer) rrr$rrrSr(r`rGrr rr) r typing_mod type_argsr tvstype_var_imported type_paramtvttvs rcreate_type_paramsrs= C&* ??m + '))*iF$'! __ 3 3%%j.$GC??o5 55%%j+tDC ??1 1!!*//48',,t:LM"I.!12 !Bw'7'7 'N&OQUVBb*//48 234 Jrc R|j}|jD] }|jst|jr'|j |j |j||j j|j}|jsM|jdz|j jz}|jt|||j|J|jt||j j||jy)zCalculate default argument values and store them. They are stored in statics for top level functions and in the function objects for nested functions (while constants are still stored computed on demand). rN)rr_rZrrrr\rlr r[r\r`rrcrrn)rrfunc_regsymtablerrr*r`s rcalculate_arg_defaultsrs MME S ??;s#?NNs/#,,1G1L1LchhE$$~~+cll.?.?? JudG4G4GHI+++ GHcll.?.?QR Sr)rrrrJ)r`rrr)rgr'rr)rrrzset[SymbolNode])rrrr) rrrrqrzlist[TypeParam]r rrrL) rrrrrrKrzdict[SymbolNode, SymbolTarget]rrJ)rW __future__rcollections.abcrrr contextlibrtypingrr r mypy.buildr mypy.maptyper mypy.nodesr rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1mypy.traverserr2 mypy.typesr3r4r5r6r7r8r9r:r;r<r=r> mypy.utilr?r@ mypy.visitorrArB mypyc.commonrCrDrErFrGrHrIrJrKrLrMrNrO mypyc.crashrP mypyc.errorsrQmypyc.ir.class_irrRrSmypyc.ir.func_irrTrUrVrWrX mypyc.ir.opsrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqmypyc.ir.rtypesrrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrmypyc.irbuild.constant_foldrmypyc.irbuild.contextrrmypyc.irbuild.ll_builderrmypyc.irbuild.mapperrmypyc.irbuild.nonlocalcontrolrrrrmypyc.irbuild.prebuildvisitorrmypyc.irbuild.preparermypyc.irbuild.targetsrrrrrmypyc.irbuild.utilrrrmypyc.irbuild.vecr mypyc.optionsrmypyc.primitives.dict_opsrrmypyc.primitives.generic_opsrrrmypyc.primitives.list_opsrrrrmypyc.primitives.misc_opsrrrrrrrmypyc.primitives.registryrrmypyc.primitives.tuple_opsrr__annotations__r ExceptionrrVrrarrrirr{rrrrrrrs, #88%''2&&&&&&&&&&N,    2<%6ZZ60;96' :2IH*)HHH I?!ML !%(*:4*@  9 (*>> L5L5^4(V*  ,   & B ' '$)'6E'MP''TS S SS- S  Sr