o 8ήc$`@sddlmZddlmZddlZddlZddlZddlZddl Z ddl Z ddl mZm Z ddl mZmZddlmZddlmZdd lmZmZdd l mZGd d d eZGd ddeZGdddeZGdddeZGdddeZdS)) defaultdict)SequenceN)typeserrors) Conversionrules) templates)order_by_target_specificity)typeofPurpose)utilsc@(eZdZdZddZddZddZdS) Ratingpromote safe_convertunsafe_convertcCsd|_d|_d|_dSNrrselfr@/tmp/pip-target-vg8gfxp4/lib/python/numba/core/typing/context.py__init__s zRating.__init__cCs|j|j|jfS)z]Returns a tuple suitable for comparing with the worse situation start first. )rrrrrrrastupleszRating.astuplecCsHt|t|ur tSt}|j|j|_|j|j|_|j|j|_|SN)typeNotImplementedrrrr)rotherrsumrrr__add__!szRating.__add__N)__name__ __module__ __qualname__ __slots__rrr rrrrrs  rc@sNeZdZdZddZddZddZejdd Z d d Z d d Z ddZ dS) CallStackz# A compile-time call stack cCsg|_t|_dSr)_stack threadingRLock_lockrrrrr0szCallStack.__init__cCs|jt||dS)zy Returns item in the stack where index=0 is the top and index=1 is the second item from the top. r )r&len)rindexrrr __getitem__4szCallStack.__getitem__cCs t|jSr)r*r&rrrr__len__;s zCallStack.__len__ccsv||j|rd}t||j|jt||||zdVW|j |j dS|j |j w)Nz2compiler re-entrant to the same function signature) matchfuncrNumbaRuntimeErrorr)acquirer&append CallFramepoprelease)rtarget typeinferfunc_idargsmsgrrrregister>s    zCallStack.registerccs"|D] }|jj|ur|VqdS)zg Yields frame that matches the function object starting from the top of stack. N)r8r/)rpy_funcframerrrfinditerLs  zCallStack.finditercCs&zt||WStyYdSw)zZ Returns the first result from `.finditer(py_func)`; or None if no match. N)nextr> StopIteration)rr<rrr findfirstUs  zCallStack.findfirstcCs&||D] }|j|kr|SqdS)z Returns first function that matches *py_func* and the arguments types in *args*; or, None if no match. N)r>r9)rr<r9r=rrrr.^s  zCallStack.matchN) r!r"r#__doc__rr,r- contextlibcontextmanagerr;r>rAr.rrrrr%+s   r%c@r) r3z# A compile-time call frame cCs$||_||_||_||_t|_dSr)r7r8r9r6set_inferred_retty)rr6r7r8r9rrrrls  zCallFrame.__init__cCsd|j|jS)NzCallFrame({}, {}))formatr8r9rrrr__repr__szCallFrame.__repr__cCs0d}|j|t|j|krd}t|dS)ztAdd *return_type* to the list of inferred return-types. If there are too many, raise `TypingError`. z3Return type of recursive function does not convergeN)rFaddr*r TypingError)r return_type RETTY_LIMITmrrradd_return_typevs   zCallFrame.add_return_typeN)r!r"r#rBrrHrPrrrrr3hs  r3c@s>eZdZdZddZddZddZdd Zd d Zd d Z dMddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!d?d@Z" A BdNdCdDZ#dEdFZ$ A BdOdGdHZ%dIdJZ&dKdLZ'dS)P BaseContextzEA typing context for storing function typing constrain template. cCs@i|_tt|_tt|_t|_tj |_ t |_ | dSr) _registriesrlist _functions _attributesr UniqueDict_globalsrdefault_type_managertmr% callstackinitrrrrrs    zBaseContext.__init__cCdS)zR Initialize the typing context. Can be overridden by subclasses. Nrrrrrr[zBaseContext.initcCs||dS)zy Refresh context with new declarations from known registries. Useful for third-party extensions. N)load_additional_registries_load_builtinsrrrrrefreshs zBaseContext.refreshc Csg}g}d}t|tjr|\}}||n)||jvr6|j|D]}|p*t|d}|t|dgq"n d}||j |d|rSdg}|D] }|d |qHd |S) zH Returns a string description of the type of a function Fgenericcasesz2No type info available for {func!r} as a callable.)r/zKnown signatures:z * {0} ) isinstancerCallableget_call_signaturesextendrThasattrgetattrr2rGjoin) rr/descdefnsparamsigstplr:sigrrrexplain_function_types$     z!BaseContext.explain_function_typec Csxz ||||}Wntjy }z |}d}WYd}~nd}~wwd}|dur)|S||||}|dur:|dur:||S)zt Resolve function type *func* for argument types *args* and *kws*. A signature is returned. N)_resolve_user_function_typerrL_resolve_builtin_function_type)rr/r9kwsreselast_exceptionrrrresolve_function_typesz!BaseContext.resolve_function_typec Csp||jvr4|j|}|D])}dD]"}|r|||}n dd|D}|||}|dur2|Sqq dSdS)NTFcSsg|]}t|qSr)r unliteral).0arrr sz>BaseContext._resolve_builtin_function_type..)rTapply) rr/r9rtrldefnsupport_literalsru fixedargsrrrrss    z*BaseContext._resolve_builtin_function_typeNcCsb||}|dur |}t|tjr"||d}|dur"||||St|tjr/||||SdS)N__call__)_lookup_globalrdrTyperesolve_getattrrxre get_call_type)rr/r9rtliteralsfuncty func_typerrrrrs    z'BaseContext._resolve_user_function_typeccsZ||jvr|j|D]}|Vq dSt|jD]}||jvr*|j|D]}|Vq$qdS)zE Get matching AttributeTemplates for the Numba type. N)rUr__mro__)rtypattrinfoclsrrr_get_attribute_templatess  z$BaseContext._get_attribute_templatescshfdd}||}|dur|S|t|}|dur|St|tjr0|}|dur2|SdSdS)z Resolve getting the attribute *attr* (a string) on the Numba type. The attribute's type is returned, or None if resolution failed. cs|}|r |dSdS)NrM)find_matching_getattr_template)routattrrrrcore s z)BaseContext.resolve_getattr..coreN)rrzrdModuleresolve_module_constants)rrrrrattrtyrrrrs  zBaseContext.resolve_getattrc Cs`t||}ddlm}||}t|||d}|D]}|||}|dur-||dSqdS)Nr)get_local_target)fnkey)templaterM)rSrnumba.core.target_extensionrr resolve) rrrrr target_hworderrrMrrrrs   z*BaseContext.find_matching_getattr_templatecCs<||D]}|||}|durttj||SqdS)z Resolve setting the attribute *attr* (a string) on the *target* type to the given *value* type. A function signature is returned, or None if resolution failed. N)rrr signaturervoid)rr6rvaluer expectedtyrrrresolve_setattr0s  zBaseContext.resolve_setattrcCs.t|tjr J|||f}d}|d||S)Nrstatic_getitemrdrrrx)rrr+r9rtrrrresolve_static_getitem=sz"BaseContext.resolve_static_getitemcCs0t|tjr J||||f}i}|d||S)Nstatic_setitemr)rr6r+rr9rtrrrresolve_static_setitemCs z"BaseContext.resolve_static_setitemcCs8t|tjs J||tj}|||||fi}|Sr)rdrrresolve_value_typeoperatorsetitemr)rr6r+rfntyrprrrresolve_setitemIs zBaseContext.resolve_setitemcCs*||f}i}|tj}||||}|Sr)rrdelitemr)rr6r+r9rtrrprrrresolve_delitemOs  zBaseContext.resolve_delitemcCs>t|tjsJt|j|}z||WStyYdSw)zb Resolve module-level global constants. Return None or the attribute type N)rdrrripymodr ValueError)rrrattrvalrrrrVs   z$BaseContext.resolve_module_constantscCsHzt|tjWSty#tj|r"ttjj|ddtjYSw)z Return the numba type of a Python value that is being used as a function argument. Integer types will all be considered int64, regardless of size. ValueError is raised for unsupported types. F)sync)r r argumentrnumbacuda is_cuda_array as_cuda_array)rvalrrrresolve_argument_typebs  z!BaseContext.resolve_argument_typec Cslz t|tj}W|Sty }z t|}WYd}~nd}~wwt|tjr)|S| |}|dur4|S|)z Return the numba type of a Python value that is being used as a runtime constant. ValueError is raised for unsupported types. N) r r constantrr erase_tracebackrdrExternalFunction_get_global_type)rrtyrv typeof_excrrrrvs  zBaseContext.resolve_value_typecCs t|}|dur||S|S)zGResolve value type and prefer Literal types whenever possible. N)r maybe_literalr)rrlitrrr!resolve_value_type_prefer_literals  z-BaseContext.resolve_value_type_prefer_literalcCs0||}|dur |St|tjrt|SdSr)rrdpytypes ModuleTyperr)rgvrrrrrs   zBaseContext._get_global_typecCs@ddlm}m}m}ddlm}m}ddlm}|t j dS)Nr)builtins arraydecl npdatetime) ctypes_utilsbufproto)eh) numba.core.typingrrrrrnumba.core.unsaferinstall_registryrbuiltin_registry)rrrrrrrrrrr_s zBaseContext._load_builtinscCr\)zT Load target-specific registries. Can be overridden by subclasses. Nrrrrrr^r]z&BaseContext.load_additional_registriescCsz|j|}Wntyt|}||j|<Ynw|dD] }|||q |dD] }|||q/|dD]0\}}||}|durR|||q>| |}|durct d||f| || ||q>dS)z~ Install a *registry* (a templates.Registry instance) of function, attribute and global declarations. functions attributesglobalsNzcannot augment %s with %s) rRKeyErrorrRegistryLoadernew_registrationsinsert_functioninsert_attributesr insert_globalaugment TypeError_remove_global_insert_global)rregistryloaderftclsrgtyexistingnewtyrrrrs,     zBaseContext.install_registrycCsHzt|}Wn tyYnwz|j|dWSty#YdSw)zD Look up the registered type for global value *gv*. N)weakrefrefrrWgetrrrrrrs  zBaseContext._lookup_globalcCsB|jjfdd}zt||}Wn tyYnw||j|<dS)zr Register type *gty* for value *gv*. Only a weak reference to *gv* is kept, if possible. cSs ||dSrr)wrr4rrr on_disposals z/BaseContext._insert_global..on_disposalN)rWr4rrr)rrrrrrrrs zBaseContext._insert_globalcCs.zt|}Wn tyYnw|j|=dS)zC Remove the registered type for global value *gv*. N)rrrrWrrrrrs   zBaseContext._remove_globalcCs|||dSr)r)rrrrrrrrIzBaseContext.insert_globalcC|j}|j||dSr)keyrUr2)ratrrrrrzBaseContext.insert_attributescCrr)rrTr2)rftrrrrrrzBaseContext.insert_functioncCs||t|dS)zInsert a user function. Args ---- - fn: object used as callee - ft: function template N)rrFunction)rfnrrrrinsert_user_functions z BaseContext.insert_user_functioncCsb||krtjS|j||}|dur|S|||}|||}|dur&|S|dur,|St||S)z Check whether conversion is possible from *fromty* to *toty*. If successful, return a numba.typeconv.Conversion instance; otherwise None is returned. N)rexactrYcheck_compatiblecan_convert_tocan_convert_frommin)rfromtytotyconvforwardbackwardrrr can_converts   zBaseContext.can_convertTFc Cst|t|kr dSt}t||D]V\}}|||}|dur#dS|s-|tjkr-dS|r7|tjkr7dS|tjkrD|jd7_q|tjkrQ|j d7_ q|tjkr^|j d7_ q|tjkrdqt d||S)z Rate the actual arguments for compatibility against the formal arguments. A Rating instance is returned, or None if incompatible. Nr unreachable) r*rziprrunsaferrsaferr Exception) r actualargs formalargsunsafe_castingexact_match_requiredrateactualformalrrrr_rate_argumentss*      zBaseContext._rate_argumentscCsxt|t|kr dSt||D]*\}}|j||durq|||}|dur*dS|tjus1J|j|||qdS)z Install possible conversions from the actual argument types to the formal argument types in the C++ type manager. Return True if all arguments can be converted. FNT)r*rrYrrrrset_compatible)rrrrrrrrrinstall_possible_conversions=s z(BaseContext.install_possible_conversionscCs|rJd||d}g} |D]#} t|t| jkr2|j|| jfi|} | dur2| | | fq| jddd| rt| d\} } |srg}| D]\}} || krSn|| qIt|dkrr||d tt|f}d |}t || SdS) aS Given actual *args* and *kws*, find the best matching signature in *cases*, or None if none matches. *key* is used for error reporting purposes. If *allow_ambiguous* is False, a tie in the best matches will raise an error. If *unsafe_casting* is False, unsafe casting is forbidden. z(Keyword arguments are not supported, yet)rrNcSs|dSrr)irrrisz.BaseContext.resolve_overload..rrr rcz#Ambiguous overloading for %s %s: %s) r*r9rr2rsortrjmapstrr)rrrbr9rtallow_ambiguousrroptions candidatescaserating best_ratebesttiedrr:rrrresolve_overloadPs4     zBaseContext.resolve_overloadcGsLdd}t||d}|d}|ddD]}|||}|dur#|Sq|S)NcSs t|ddS)zfUses bitwidth to order numeric-types. Fallback to stable, deterministic sort. bitwidthr)ri)objrrrkeyfuncs z(BaseContext.unify_types..keyfuncr rr )sorted unify_pairs)rtypelistrunifiedtprrr unify_typess  zBaseContext.unify_typescCs||kr|S|tjur |S|tjur|S|||}|dur |S|||}|dur,|S|j||d}|dur>|tjkr>|S|j||d}|durP|tjkrP|St|tjs\t|tjrlt|}t|}| ||SdS)zr Try to unify the two given types. A third type is returned, or None in case of failure. N)rr) r undefinedunifyrrrrdLiteralrzr)rfirstsecondr rrrrrs2         zBaseContext.unify_pairsrry)TTF)(r!r"r#rBrr[r`rqrxrsrrrrrrrrrrrrrrrr_r^rrrrrrrrrrr rr"rrrrrrQsT           / rQc@seZdZddZdS)Contextc Csddlm}m}m}m}m}m}m}m}m } | |j | |j | |j | |j | |j | |j | |j | |j | | j dS)Nr ) cffi_utils cmathdeclenumdecllistdeclmathdeclnpydecl randomdeclsetdecldictdecl) r)r*r+r,r-r.r/r0r1rr) rr)r*r+r,r-r.r/r0r1rrrr^s,       z"Context.load_additional_registriesN)r!r"r#r^rrrrr(s r() collectionsrcollections.abcrrrrr'rCrr numba.corernumba.core.typeconvrrrrnumba.core.utilsr r r r objectrr%r3rQr(rrrrs.    =;