o 2gAr@sTUdZddlmZddlmZmZddlmZmZm Z m Z m Z m Z m Z mZmZmZmZmZmZddlmZmZddlmZmZmZmZmZmZmZmZddl 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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9ddl:m;Z;dd lZ>m?Z?m@Z@dd lAmBZBmCZCmDZDmEZEdd lFmGZGmHZHmIZImJZJdd lKmLZLdd lMmNZNede egeefZOiZPdeQd< ddddZRddd ZS ddd"d#ZT ddd&d'ZUeUd(dd)d*ZVeUd+eUd,eUd-eUd.eUd/eUd0eUd1eUd2dd3d4ZWeUd5dd6d7ZXeUd8dd9d:ZYeUd8dd;d<ZZeUd=dd>d?Z[eUd@ddAdBZ\eUdCeUdDddEdFZ]eUd=eUdGeUdHeUdCeUdDeUdIeUdJeUdKe8eUdLe6eUdMe'eUdMe7ddNdOZ^eUdPddQdRZ_eUdSddTdUZ`dd^d_ZaeUd`ddadbZbeUdceUddeUdeeUdfddgdhZceUdiddjdkZdeUdlddmdnZeeUdoe'ddpdqZfeUdre8ddsdtZgeUdKe8ddudvZheUd/ddwdxZieUd0ddydzZjeUd1dd{d|ZkeUd2dd}d~ZldddZmeUd,dddZneUddddZoeUd-dddZpdS)a0Special case IR generation of calls to specific builtin functions. Most special cases should be handled using the data driven "primitive ops" system, but certain operations require special handling that has access to the AST/IR directly and can make decisions/optimizations based on it. These special cases can be implemented here. For example, we use specializers to statically emit the length of a fixed length tuple and to emit optimized code for any()/all() calls with generator comprehensions as the argument. See comment below for more documentation. ) annotations)CallableOptional) ARG_NAMEDARG_POSCallExprDictExpr Expression GeneratorExprIntExprListExpr MemberExprNameExprRefExprStrExpr TupleExpr)AnyType TypeOfAny) BasicBlockExtendIntegerRaiseStandardErrorRegisterTruncate UnreachableValue) RInstance RPrimitiveRTupleRTypebool_rprimitivec_int_rprimitivedict_rprimitiveint16_rprimitiveint32_rprimitiveint64_rprimitiveint_rprimitiveis_bool_rprimitiveis_dict_rprimitiveis_fixed_width_rtypeis_float_rprimitiveis_int16_rprimitiveis_int32_rprimitiveis_int64_rprimitiveis_int_rprimitiveis_list_rprimitiveis_uint8_rprimitivelist_rprimitiveset_rprimitivestr_rprimitiveuint8_rprimitive) IRBuilder)comprehension_helper*sequence_from_generator_preallocate_helpertranslate_list_comprehensiontranslate_set_comprehension)FormatOpconvert_format_expr_to_strjoin_formatted_stringstokenizer_format_call) dict_items_op dict_keys_opdict_setdefault_spec_init_opdict_values_op)new_list_set_item_op)new_tuple_set_item_opr5z1dict[tuple[str, RType | None], list[Specializer]] specializersNbuilderexprrcalleername str | Nonetyp RType | Nonereturn Value | NonecCsB|r||ftvrt||fD]}||||}|dur|SqdSN)rD)rErFrGrHrJ specializervalrQP/home/garg/my-data/venv/lib/python3.10/site-packages/mypyc/irbuild/specialize.py_apply_specializationns rScCst||||jS)zIInvoke the Specializer callback for a function if one has been registered)rSfullnamerErFrGrQrQrRapply_function_specialization~srVr cCs$|dur|jn|j}t|||||S)zGInvoke the Specializer callback for a method if one has been registeredN)rTrHrS)rErFrGrJrHrQrQrRapply_method_specializationsrWstr$Callable[[Specializer], Specializer]csdfdd }|S)zDecorator to register a function as being a specializer. There may exist multiple specializers for one function. When translating method calls, the earlier appended specializer has higher priority. f SpecializerrLcstfg||SrN)rD setdefaultappend)rZrHrJrQrRwrappersz$specialize_function..wrapperN)rZr[rLr[rQ)rHrJr_rQr^rRspecialize_functions r`zbuiltins.globalscCst|jdkr |SdS)Nr)lenargsload_globals_dictrUrQrQrRtranslate_globalssrdz builtins.absz builtins.intzbuiltins.floatzbuiltins.complexzmypy_extensions.i64zmypy_extensions.i32zmypy_extensions.i16zmypy_extensions.u8cCst|jdkrK|jtgkrKt|trK|jd}||}|jdd}|dvr+d}nd|d}t|t rK|j |rK| |}| ||gd|jSdS)zSpecialize calls on native classes that implement the associated dunder. E.g. i64(x) gets specialized to x.__int__() if x is a native instance. r.)i64i32i16u8__int____N)rarb arg_kindsr isinstancer node_typerTsplitrclass_ir has_methodacceptgen_method_callline)rErFrGargarg_typ shortnamemethodobjrQrQrR$translate_builtins_with_unary_dunders$    r{z builtins.lencCst|jdkrB|jtgkrB|jd}||}t|tr(||tt|j St ||r2d}nd}|j||d}| ||j SdS)NrerTF can_borrow) rarbrmrrornrrsrtypesr/ builtin_lenru)rErFrGrv expr_rtypeborrowrzrQrQrR translate_lens    rz builtins.listcCst|jdkr |jtgksdS|jd}t|tr"|js"t|jts$dS|jj}|jj }| |}t |r9|dvs;dS| |}|dkrM| t|g|jS|dkrZ| t|g|jS| t|g|jS)zSpecialize a common case when list() is called on a dictionary view method call. For example: foo = list(bar.keys()) reNr)keysvaluesitemsrr)rarbrmrrnrrGr rFrHror(rscall_cr?rurAr>)rErFrGrvbaseattrrtyperzrQrQrRdict_methods_fast_paths    rcCJt|jdkr#|jdtkr#t|jdtr#t||jd|jjt dSdS)zSpecial case for simplest list comprehension. For example: list(f(x) for x in some_list/some_tuple/some_str) 'translate_list_comprehension()' would take care of other cases if this fails. rerempty_op_llbuilder set_item_opN) rarbrmrrnr r7rEnew_list_op_with_lengthrBrUrQrQrR"translate_list_from_generator_call rzbuiltins.tuplecCr)zSpecial case for simplest tuple creation from a generator. For example: tuple(f(x) for x in some_list/some_tuple/some_str) 'translate_safe_generator_call()' would take care of other cases if this fails. rerrN) rarbrmrrnr r7rEnew_tuple_with_lengthrCrUrQrQrR#translate_tuple_from_generator_callrr builtins.setcCs@t|jdkr|jdtkrt|jdtrt||jdSdS)zSpecial case for set creation from a generator. For example: set(f(...) for ... in iterator/nested_generators...) rerN)rarbrmrrnr r9rUrQrQrR!translate_set_from_generator_call(s  r builtins.minz builtins.maxc Cs|jttgkr||jd||jd}}t||}|jdkr.|||d|j}n |||d|j}t t t }}} | |||| || || ||j|j|j|| | || || ||j|j|j|| | | |SdS)Nrrer<>)rmrrsrbrrorT binary_opruradd_bool_branchactivate_blockassigncoercetypegoto) rErFrGxyresult comparison true_block false_block next_blockrQrQrRfaster_min_max:s""      rzbuiltins.frozensetz builtins.dictzbuiltins.sortedzcollections.OrderedDictjoinextendupdatec st|jdkrb|jdtkrbt|jdtrbt|trF|j |j t |jdgfdd|jddD ||j |j|jS||t |jdgfdd|jddDSdS)zuSpecial cases for things that consume iterators where we know we can safely compile a generator into a list. rcg|]}|qSrQrs.0rvrErQrR rz1translate_safe_generator_call..reNcrrQrrrrQrRrr)rarbrmrrnr r rtrsrFrHr8roru arg_namescall_refexpr_with_argsrUrQrrRtranslate_safe_generator_callVs0   rz builtins.anycCsLt|jdkr$|jtgkr$t|jdtr$t||jd|jdd|jSdS)NrercSs|SrNrQrrQrQrRsz$translate_any_call..) rarbrmrrnr any_all_helperfalsetruerUrQrQrRtranslate_any_calls  rz builtins.allcsRtjdkr'jtgkr'tjdtr'tjdjfddjSdS)Nrercs|djS)Nnot)unary_oprurrErFrQrRrsz$translate_all_call..) rarbrmrrnr rrrrUrQrrRtranslate_all_calls  rgenr initial_valueCallable[[], Value]modifyCallable[[Value], Value] new_valuerc stt|dttjjjj}t t t dfdd }t ||j  S)NrLNonecsPj}|ddS)Nr)rs left_exprrrrr)rrE exit_blockrrrrretvalrrQrRgen_inner_stmtss   z'any_all_helper..gen_inner_stmtsrLr) rr rlistzipindices sequences condlistsis_asyncrr6rugoto_and_activate)rErrrr loop_paramsrrQrrRrs rz builtins.sumcst|jdvr|jdtkrt|jdtsdSt|jdkr0|jdttfvr*dS|jd}ntd}|jd|}t |  ||ddd fdd }t tjjjj}t||jS) N)rerrrerrLrc s*j}|ddddS)N+r)rsrrr) call_exprrEgen_exprrrQrRrs z+translate_sum_call..gen_inner_stmtsr)rarbrmrrnr rr rorrrrsrrrrrrr6ru)rErFrG start_expr target_typerrrQrrRtranslate_sum_calls(   rzdataclasses.fieldzattr.ibz attr.attribz attr.FactorycCsttj|j|<dS)a,Special case for 'dataclasses.field', 'attr.attrib', and 'attr.Factory' function calls because the results of such calls are type-checked by mypy using the types of the arguments to their respective functions, resulting in attempted coercions by mypyc that throw a runtime error. N)rr from_errorr~rUrQrQrR translate_dataclasses_field_calls rz builtins.nextcs|jtgttgfvrt|jdtsdS|jdt|t|jdkr/|jdnd}t dfdd }t t j j jj}t||j|rd|jjnttjd|jtS) a6Special case for calling next() on a generator expression, an idiom that shows up some in mypy. For example, next(x for x in l if x.id == 12, None) will generate code that searches l for an element where x.id == 12 and produce the first such object, or None if no such element exists. rNrerLrcs(jjjdSrN)rrsrrurrQrErrrrQrRrsz,translate_next_call..gen_inner_stmtsr)rmrrnrbr rrorarsrrrrrrrr6rurrraddrSTOP_ITERATIONrr)rErFrG default_valrrrQrrRtranslate_next_calls$  "   rzbuiltins.isinstancecCst|jdkrK|jttgkrKt|jdttfrKttj |j |jd<| |jd}|durKt dd|D}|j |jd|d}|j|||jSdS)zSpecial case for builtins.isinstance. Prevent coercions on the thing we are checking the instance of - there is no need to coerce something to a new type before checking what type it is, and the coercion could lead to bugs. rrerNcss&|]}|jo|j o|j VqdSrN) is_ext_classinherits_pythonallow_interpreted_subclasses)rirrQrQrR 0s  z'translate_isinstance..r|)rarbrmrrnrrrrrr~flatten_classesallrsrEisinstance_helperru)rErFrGirsr}rzrQrQrRtranslate_isinstances rr\cCst|jdkr{|jttgkr{t|tr{|jd}t|tr,t|jr$dStdt |j }n6t|t r@t|jr8dStdt |j }n"t|t r`t|j tr`|j jdkr`t|jrXdStdt |j }ndS||j}||jd}|t|||g|j SdS)aSpecial case for 'dict.setdefault' which would only construct default empty collection when needed. The dict_setdefault_spec_init_op checks whether the dict contains the key and would construct the empty collection only once. For example, this specializer works for the following cases: d.setdefault(key, set()).add(value) d.setdefault(key, []).append(value) d.setdefault(key, {})[inner_key] = inner_val rreNrr)rarbrmrrnr r rrr!rurrrGrrTrsrFrr@)rErFrGrv data_type callee_dictkey_valrQrQrRtranslate_dict_setdefault9s8         rformatcCst|tr?t|jtr?|jtt|jkr?|jj}t |}|dur$dS|\}}t |||j |j }|dur7dSt ||||j SdSrN)rnr rFrrmcountrravaluer=r;rbrur<)rErFrG format_strtokensliterals format_ops substitutionsrQrQrRtranslate_str_formatgs rcCsnt|trt|jtr|jjdkr|jtgkrt|jdtr|jdj D]C}t|tr-q%t|t rft|j tr>|j j dkrAdSt|j jtrO|j jjdkrRdSt|jdtrb|jdjdkredSq%dSg}g}|jdj D]+}t|tr|jdkr| tj| |qst|t r| tj| |jdqst||||j}|durdSt|d||jSdS)zSpecial case for f-string, which is translated into str.join() in mypy AST. This specializer optimizes simplest f-strings which don't contain any format operation. rrNz{:{}}re)rnr rFrrrmrrbr rrrGrHr]r:STRr;rur<)rErFrGitemrexprsrrQrQrRtranslate_fstring{sJ            rcCst|jdks|jdtkrdS|jd}||}t|r#||St|s+t|r<||}| t |t d|j dSt |rQ||}| t |t d|j dSt|sYt|rf||}||t |j SdS)NrerTsignedruF)rarbrmrror-rsr,r+rrr%rur0r.r'rrErFrGrvarg_typerPrQrQrR translate_i64s       rcCst|jdks|jdtkrdS|jd}||}t|r#||St|r7||}|t |t |j dSt |rL||}|t |t d|j dSt|ra||}|t |t d|j dSt|sit|r{||}t|t }||t |j SdS)NrerruTrF)rarbrmrror,rsr-rrr$rur+rr0r.r'truncate_literalrrrQrQrR translate_i32s(        rcCst|jdks|jdtkrdS|jd}||}t|r#||St|s+t|r;||}| t |t |j dSt |rP||}| t|t d|j dSt|sXt|rj||}t|t }||t |j SdS)NrerrFr)rarbrmrror+rsr,r-rrr#rur0rr.r'rrrrQrQrR translate_i16s"       r cCst|jdks|jdtkrdS|jd}||}t|r#||St|s/t|s/t |r?||}| t |t |j dSt|sGt|rY||}t|t }||t |j SdS)Nrerr)rarbrmrror0rsr+r,r-rrr4rur.r'rrrrQrQrR translate_u8s&      r rrrcCs\t|ts|S|}d|jd>d}||@}|jr)||ddkr)||d8}t||S)zIf value is an integer literal value, truncate it to given native int rtype. For example, truncate 256 into 0 if rtype is u8. rer)rnr numeric_valuesize is_signed)rrr max_unsignedrQrQrRrs   rcCsjt|jdks|jdtkrdS|jd}||}t|s&t|s&t|r3||}| |t |j SdSNrer) rarbrmrror'r.r)rsrr&ru)rErFrGrvrsrcrQrQrR translate_ints   rz builtins.boolcCs@t|jdks|jdtkrdS|jd}||}|j|Sr)rarbrmrrsrE bool_value)rErFrGrvrrQrQrRtranslate_bool$s    rcCsJt|jdks|jdtkrdS|jd}||}t|r#||SdSr)rarbrmrror*rs)rErFrGrvrrQrQrRtranslate_float-s   rrN) rEr5rFrrGrrHrIrJrKrLrM)rEr5rFrrGrrLrM) rEr5rFrrGr rJrKrLrM)rHrXrJrKrLrY) rEr5rr rrrrrrrLr)rrrrrLr)q__doc__ __future__rtypingrr mypy.nodesrrrrr r r r r rrrr mypy.typesrr mypyc.ir.opsrrrrrrrrmypyc.ir.rtypesrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4mypyc.irbuild.builderr5mypyc.irbuild.for_helpersr6r7r8r9"mypyc.irbuild.format_str_tokenizerr:r;r<r=mypyc.primitives.dict_opsr>r?r@rAmypyc.primitives.list_opsrBmypyc.primitives.tuple_opsrCr[rD__annotations__rSrVrWr`rdr{rrrrrrrrrrrrrrrrrrrr r rrrrrQrQrQrRs <(l              $    & +  -  1