Ë
    pPêjf›  ã                  ó�  — U d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl	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mZmZmZmZmZmZ ddlm Z m!Z!m"Z" ddl#m$Z$m%Z%m&Z& dd	l'm(Z(m)Z) dd
l*m+Z+m,Z, ddl-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z; ddl<m=Z=m>Z>m?Z?m@Z@ ddlAmBZBmCZC ddlDmEZEmFZFmGZGmHZHmIZI ddlJmKZKmLZLmMZMmNZNmOZO ddlPmQZQmRZR ddlSmTZTmUZUmVZVmWZWmXZX ddlYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z` ddlambZb d3d„Zc G d„ d«      Zd G d„ ded«      Ze G d„ ded«      Zf G d„ def«      Zg G d„ deg«      Zhd4d„Zi	 	 	 	 	 	 	 	 	 	 d5d „Zjd!Zkd"eld#<   d4d$„Zmd6d%„Zn	 	 	 	 	 	 	 	 	 	 d7d&„Zo	 d8	 	 	 	 	 	 	 	 	 	 	 d9d(„Zp	 	 	 	 	 	 	 	 	 	 	 	 	 	 d:d)„Zq	 	 	 	 	 	 d;d*„Zr	 	 	 	 	 	 	 	 d<d+„Zsd3d,„Ztd=d-„Zu	 	 	 	 	 	 	 	 	 	 d>d.„Zvd?d/„Zw	 	 	 	 	 	 	 	 d@d0„ZxdAd1„Zy	 dB	 	 	 	 	 	 	 	 	 dCd2„Zzy')Dz9Transform class definitions from the mypy AST form to IR.é    )Úannotations)Úabstractmethod)ÚCallable)ÚFinal)ÚARG_POSÚEXCLUDED_ENUM_ATTRIBUTESÚTYPE_VAR_TUPLE_KINDÚAssignmentStmtÚCallExprÚClassDefÚ	DecoratorÚEllipsisExprÚExpressionStmtÚFuncDefÚLvalueÚ
MemberExprÚNameExprÚOverloadedFuncDefÚPassStmtÚStrExprÚTempNodeÚTypeInfoÚ	TypeParamÚVarÚis_class_var)ÚInstanceÚUnboundTypeÚget_proper_type)ÚGENERATOR_HELPER_NAMEÚMYPYC_DEFAULTS_SETUPÚPROPSET_PREFIX)ÚClassIRÚNonExtClassInfo)ÚFuncDeclÚFuncSignature)ÚNAMESPACE_TYPEÚ
BasicBlockÚBranchÚCallÚ
InitStaticÚLoadAddressÚLoadErrorValueÚ
LoadStaticÚ
MethodCallÚRegisterÚReturnÚSetAttrÚTupleSetÚValue)ÚRTypeÚbool_rprimitiveÚdict_rprimitiveÚobject_rprimitive)Ú	IRBuilderÚcreate_type_params)Úgen_property_getter_irÚgen_property_setter_irÚhandle_ext_methodÚhandle_non_ext_methodÚ	load_type)Údataclass_typeÚdefault_attr_nameÚget_func_defÚis_constantÚis_dataclass_decorator)Údict_new_opÚexact_dict_set_item_op)Úiter_opÚnext_opÚpy_get_item_opÚpy_hasattr_opÚpy_setattr_op)Údataclass_sleight_of_handÚ	import_opÚnot_implemented_opÚpy_calc_meta_opÚpy_init_subclass_opÚpytype_from_template_opÚtype_object_op)Ú
is_subtypec                óà  ‡— |j                   | j                  j                  vr| j                  d|j                  «       y| j                  j                  |j                      Št        ˆfd„t        t        ‰j                  «      dz
  «      D «       «      r| j                  d|j                  «       ‰j                  rS‰j                  D ]D  }|j                  rŒ| j                  dj                  |j                  «      |j                  «       ŒF ‰j                  rHt        |«      }|€t        | |«      }n:|dv rt!        | |«      }n)|dk(  rt#        | |«      }nt%        |«      ‚t'        | |«      }i | _        |j+                  «       | _        ‰| _        |j.                  j0                  D �]õ  }t3        |t4        t6        t8        f«      r=|j:                  t<        k(  r*| j                  d	|j:                  › d
�|j                  «       t3        |t8        «      rˆ|j>                  r|t3        |t&        «      r| j                  d|j                  «       |j@                  D ]@  }| jC                  |j                  «      5  |jE                  tG        |«      «       ddd«       ŒB Œôt3        |t4        t6        t8        f«      ro|j                   jH                  |j:                     jJ                  r�Œ>| jC                  |j                  «      5  |jE                  tG        |«      «       ddd«       �Œ~t3        |tL        «      s*t3        |tN        «      rt3        |jP                  tR        «      r�Œºt3        |tT        «      rät        |jV                  «      dk7  r| j                  d|j                  «       �Œ |jV                  d   }t3        |tX        «      s| j                  d|j                  «       �Œ=|j[                  ||«       t]        |«      s|j^                  s�Œht3        |j`                  tb        «      sJ |j`                  «       ‚d| j(                  |j`                  <   �Œ®t3        |tN        «      rt3        |jP                  td        «      r�ŒÚ| j                  d|j                  «       �Œø i | _        d| _        d| _        ‰jf                  jA                  «       D ]î  \  }}	|	jh                  sŒ|	jj                  sŒ tm        | |	|‰jn                  «      }
| jp                  js                  |
«       |
‰jt                  |
jv                  j:                  <   d}tx        |z   }|‰jf                  v rOt{        | ‰jf                  |   |‰jn                  «      }| jp                  js                  |«       |‰jt                  |<   |
|f‰j|                  |<   Œð |j                  ‰«       y# 1 sw Y   �Œ…xY w# 1 sw Y   �ŒBxY w)aÀ  Create IR for a class definition.

    This can generate both extension (native) and non-extension
    classes.  These are generated in very different ways. In the
    latter case we construct a Python type object at runtime by doing
    the equivalent of "type(name, bases, dict)" in IR. Extension
    classes are defined via C structs that are generated later in
    mypyc.codegen.emitclass.

    This is the main entry point to this module.
    z&Nested class definitions not supportedNc              3  óv   •K  — | ]0  }‰j                   |   j                  ‰j                   |d z      k7  –— Œ2 y­w)é   N)Úbase_mroÚbase)Ú.0ÚiÚirs     €ú[/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypyc/irbuild/classdef.pyú	<genexpr>z&transform_class_def.<locals>.<genexpr>m   s1   øè ø€ Ò
Z¸ˆ2�;‰;�q‰>×Ñ "§+¡+¨a°!©eÑ"4Õ4Ñ
Zùs   ƒ69rU   z9Multiple inheritance is not supported (except for traits)z5Base class "{}" does not allow interpreted subclasses)Údataclassesz	attr-autoÚattrzMethod name "z$" is reserved for mypyc internal usez7Property setters not supported in non-extension classesz1Multiple assignment in class bodies not supportedr   z9Only assignment to variables is supported in class bodiesz#Unsupported statement in class body)@ÚinfoÚmapperÚ
type_to_irÚerrorÚlineÚanyÚrangeÚlenrV   Úallow_interpreted_subclassesÚmroÚformatÚfullnameÚis_ext_classr?   ÚExtClassBuilderÚDataClassBuilderÚAttrsClassBuilderÚ
ValueErrorÚNonExtClassBuilderÚclass_body_classvarsÚclass_body_objÚclass_body_irÚdefsÚbodyÚ
isinstancer   r   r   Únamer   Úis_propertyÚitemsÚcatch_errorsÚ
add_methodrA   ÚnamesÚplugin_generatedr   r   Úexprr   r
   Úlvaluesr   Úadd_attrr   Úis_final_defÚnoder   r   Úmethod_declsÚimplicitÚis_prop_getterr:   Úis_traitÚ	functionsÚappendÚmethodsÚdeclr!   r;   Ú
propertiesÚfinalize)ÚbuilderÚcdefÚparentÚcls_typeÚcls_builderÚstmtÚitemÚlvaluerw   rŠ   Ú	getter_irÚ	setter_irÚsetter_namerZ   s                @r[   Útransform_class_defr˜   X   sÐ  ø€ ð ‡y�y˜Ÿ™×1Ñ1Ñ1Ø�‰Ð>ÀÇ	Á	ÔJØà	�‰×	"Ñ	" 4§9¡9Ñ	-€Bô
 Ó
Z¼eÄCÈÏÉÓDTÐWXÑDXÓ>YÔ
ZÔZØ�‰ÐQÐSW×S\ÑS\Ô]à	×&Ò&Ø—f‘fò 	ˆFØ×6Ó6Ø—‘ØK×RÑRØŸ™óð —I‘Iõ	ð	ð 
‡‚Ü! $Ó'ˆØÐÜ(7¸ÀÓ(F‰KØÐ5Ñ5Ü*¨7°DÓ9‰KØ˜ÒÜ+¨G°TÓ:‰Kä˜XÓ&Ð&ä(¨°$Ó7ˆð
 $&€GÔ Ø(×7Ñ7Ó9€GÔØ€GÔà—	‘	—‘ó 3Lˆä�tœg¤yÔ2CÐDÔEØ—	‘	Ô2Ò2à�M‰MØ §	¡	˜{Ð*NÐOÐQU×QZÑQZôô �dÔ-Ô.°4×3CÒ3CÜ˜+Ô'9Ô:ð —‘ÐWÐY]×YbÑYbÔcØŸ
™
ò ?�Ø×)Ñ)¨$¯)©)Ó4ñ ?Ø×*Ñ*¬<¸Ó+=Ô>÷?ð ?ñ?ô ˜œw¬	Ô3DÐEÔFð �y‰y�‰˜tŸy™yÑ)×:Ò:ÙØ×%Ñ% d§i¡iÓ0ñ ;Ø×&Ñ&¤|°DÓ'9Ô:÷;ñ ;ä˜œhÔ'Ü�tœ^Ô,´¸D¿I¹IÄ|Ô1TáÜ˜œnÔ-Ü�4—<‘<Ó  AÒ%Ø—‘ÐQÐSW×S\ÑS\Ô]ÙØ—\‘\ !‘_ˆFÜ˜f¤hÔ/Ø—‘ØOÐQU×QZÑQZôñ ð × Ñ  ¨Ô.ä˜FÔ# t×'8Ô'8Ü! &§+¡+¬sÔ3Ð@°V·[±[Ó@Ð3Ø<@�×,Ñ,¨V¯[©[Ó9ä˜œnÔ-´*¸T¿Y¹YÌÔ2Páà�M‰MÐ?ÀÇÁÖKðg3Lðl $&€GÔ Ø!€GÔØ €GÔð —o‘o×+Ñ+Ó-ò 9‰
ˆˆdØ�=‹=˜T×0Ó0Ü.¨w¸¸dÀBÇKÁKÓPˆIØ×Ñ×$Ñ$ YÔ/Ø.7ˆB�J‰J�y—~‘~×*Ñ*Ñ+àˆIÜ(¨4Ñ/ˆKØ˜bŸo™oÑ-Ü2Ø˜RŸ_™_¨[Ñ9¸4ÀÇÁó�	ð ×!Ñ!×(Ñ(¨Ô3Ø*3�—
‘
˜;Ñ'à#,¨iÐ"8ˆB�M‰M˜$Òð9ð& ×Ñ˜Õ÷?ñ ?ú÷;ñ ;ús   É9WÌW#×W ×#W-	c                  óV   — e Zd ZdZdd„Zed	d„«       Zed
d„«       Zedd„«       Zdd„Z	y)ÚClassBuilderzKCreate IR for a class definition.

    This is an abstract base class.
    c                ó.   — || _         || _        g | _        y ©N)r�   rŽ   Úattrs_to_cache)Úselfr�   rŽ   s      r[   Ú__init__zClassBuilder.__init__è   s   € ØˆŒØˆŒ	Ø:<ˆÕó    c                 ó   — y)zAdd a method to the class IRN© ©rž   Úfdefs     r[   r{   zClassBuilder.add_methodí   ó   � r    c                 ó   — y)z Add an attribute to the class IRNr¢   ©rž   r”   r’   s      r[   r€   zClassBuilder.add_attrñ   r¥   r    c                 ó   — y)z5Perform any final operations to complete the class IRNr¢   )rž   rZ   s     r[   rŒ   zClassBuilder.finalizeõ   r¥   r    c                 ó   — y)zêReturn the object to use for loading class attributes during class body init.

        For extension classes, this is the type object. For non-extension classes,
        this is the class dict. Returns None if not applicable.
        Nr¢   ©rž   s    r[   rr   zClassBuilder.class_body_objù   s   € ð r    N©r�   r8   rŽ   r   ÚreturnÚNone©r¤   r   r¬   r­   ©r”   r   r’   r
   r¬   r­   ©rZ   r"   r¬   r­   ©r¬   zValue | None)
Ú__name__Ú
__module__Ú__qualname__Ú__doc__rŸ   r   r{   r€   rŒ   rr   r¢   r    r[   rš   rš   â   sO   „ ñó
=ð
 ò+ó ð+ð ò/ó ð/ð òDó ðDôr    rš   c                  óH   ‡ — e Zd Zdˆ fd„Zdd„Zd	d„Zd
d„Zdd„Zdd„Zˆ xZ	S )rp   c                óP   •— t         ‰| �  ||«       | j                  «       | _        y rœ   ©ÚsuperrŸ   Úcreate_non_ext_infoÚnon_ext©rž   r�   rŽ   Ú	__class__s      €r[   rŸ   zNonExtClassBuilder.__init__  ó"   ø€ Ü‰Ñ˜ $Ô'Ø×/Ñ/Ó1ˆ�r    c                ó.   — | j                   j                  S rœ   )r»   Údictrª   s    r[   rr   z!NonExtClassBuilder.class_body_obj  s   € Ø�|‰|× Ñ Ð r    c                óN  — t        | j                  | j                  «      }t        | j                  | j                  |«      }t	        | j                  | j                  ||«      }| j                  j                  t        g | j                  j                  «      }t        ||||«      S rœ   )	Úpopulate_non_ext_basesr�   rŽ   Úfind_non_ext_metaclassÚsetup_non_ext_dictÚcall_crD   rc   r#   )rž   Únon_ext_basesÚnon_ext_metaclassÚnon_ext_dictÚnon_ext_annss        r[   rº   z&NonExtClassBuilder.create_non_ext_info
  s}   € Ü.¨t¯|©|¸T¿Y¹YÓGˆÜ2°4·<±<ÀÇÁÈMÓZÐÜ)Ø�L‰L˜$Ÿ)™)Ð%6¸ó
ˆð —|‘|×*Ñ*¬;¸¸D¿I¹I¿N¹NÓKˆÜ˜|¨]¸LÐJ[Ó\Ð\r    c                ó\   — t        | j                  | j                  | j                  |«       y rœ   )r=   r�   r»   rŽ   r£   s     r[   r{   zNonExtClassBuilder.add_method  s   € Ü˜dŸl™l¨D¯L©L¸$¿)¹)ÀTÕJr    c                ó¸   — t        | j                  | j                  ||«       t        | j                  | j                  ||| j                  | j
                  «       y rœ   )Úadd_non_ext_class_attr_annr�   r»   Úadd_non_ext_class_attrrŽ   r�   r§   s      r[   r€   zNonExtClassBuilder.add_attr  s?   € Ü" 4§<¡<°·±¸vÀtÔLÜØ�L‰L˜$Ÿ,™,¨°°d·i±iÀ×ATÑATõ	
r    c                ó  — t        | j                  || j                  | j                  j                  «      }t        | j                  | j                  |«      }| j                  j                  || j                  j                  «       | j                  j                  t        || j                  j                  | j                  j                  t        «      «       | j                  j                  t        | j                  j                  «       | j                  j                  | j                  j                  «      |g| j                  j                  «       t!        | j                  | j"                  | j                  «       y rœ   )Úload_non_ext_classr�   r»   rŽ   rc   Úload_decorated_classÚset_immortal_if_free_threadedÚaddr*   rw   Úmodule_namer&   rÅ   rE   Úload_globals_dictÚload_strÚcache_class_attrsr�   )rž   rZ   Únon_ext_classs      r[   rŒ   zNonExtClassBuilder.finalize  sý   € ä*¨4¯<©<¸¸T¿\¹\È4Ï9É9Ï>É>ÓZˆÜ,¨T¯\©\¸4¿9¹9ÀmÓTˆð 	�‰×2Ñ2°=À$Ç)Á)Ç.Á.ÔQð 	�‰×ÑÜ�} d§i¡i§n¡n°d·l±l×6NÑ6NÔP^Ó_ô	
ð
 	�‰×ÑÜ"à—‘×.Ñ.Ó0Ø—‘×%Ñ% d§i¡i§n¡nÓ5Øðð
 �I‰I�N‰Nô	
ô 	˜$Ÿ,™,¨×(;Ñ(;¸T¿Y¹YÕGr    r«   r±   ©r¬   r#   r®   r¯   r°   )
r²   r³   r´   rŸ   rr   rº   r{   r€   rŒ   Ú__classcell__©r½   s   @r[   rp   rp     s$   ø„ õ2ó!ó
]óKó
÷Hr    rp   c                  ó@   ‡ — e Zd Zdˆ fd„Zdd„Zdd„Zd	d„Zd
d„Zˆ xZS )rl   c                óH   •— t         ‰| �  ||«       t        ||«      | _        y rœ   )r¹   rŸ   Úallocate_classÚtype_objr¼   s      €r[   rŸ   zExtClassBuilder.__init__<  s    ø€ Ü‰Ñ˜ $Ô'ä-¨g°tÓ<ˆ�r    c                ó   — | j                   S rœ   )rÞ   rª   s    r[   rr   zExtClassBuilder.class_body_objA  s   € Ø�}‰}Ðr    c                óF   — t        | j                  | j                  |«       y rœ   )r<   r�   rŽ   r£   s     r[   r{   zExtClassBuilder.add_methodD  s   € Ü˜$Ÿ,™,¨¯	©	°4Õ8r    c                óf  — t        |j                  t        «      ry t        |«      s|j                  sy | j
                  j                  | j                  j                  «      }| j
                  j                  |j                  «      }| j
                  j                  t        || j
                  j                  |j                  «      |g|j                  «       | j
                  j                  «       r?|j                  r2| j
                  j!                  ||| j                  j                  «       y y y rœ   )rv   Úrvaluer   r   r�   r�   Úload_native_type_objectrŽ   rj   ÚacceptÚprimitive_oprJ   rÕ   rw   rc   Únon_function_scopeÚinit_final_static)rž   r”   r’   ÚtypÚvalues        r[   r€   zExtClassBuilder.add_attrG  sÔ   € ä�d—k‘k¤8Ô,Øä˜VÔ$¨×(9Ò(9ØØ�l‰l×2Ñ2°4·9±9×3EÑ3EÓFˆØ—‘×#Ñ# D§K¡KÓ0ˆØ�‰×!Ñ!Ü˜C §¡×!6Ñ!6°v·{±{Ó!CÀUÐKÈTÏYÉYô	
ð �<‰<×*Ñ*Ô,°×1BÒ1BØ�L‰L×*Ñ*¨6°5¸$¿)¹)¿.¹.ÕIð 2CÐ,r    c                óæ  — | j                   j                  t        | j                  g| j                  j
                  «       | j                   j                  j                  rt        |j                  v r_t        | j                   | j                  «      \  }}|j                  j                  |«       t        | j                   | j                  |«       t        | j                   | j                  «       y rœ   )r�   rÅ   rO   rÞ   rŽ   rc   ÚoptionsÚseparater    rƒ   Úfind_attr_initializersÚattrs_with_defaultsÚupdateÚgenerate_attr_defaults_initÚcreate_ne_from_eq)rž   rZ   rî   Údefault_assignmentss       r[   rŒ   zExtClassBuilder.finalizeV  s¤   € à�‰×ÑÔ/°$·-±-°À$Ç)Á)Ç.Á.ÔQð �|‰|×#Ñ#×,Ò,Ô0DÈÏÉÑ0WÜ7MØ—‘˜dŸi™ió8Ñ4ÐÐ!4ð ×"Ñ"×)Ñ)Ð*=Ô>Ü'¨¯©°d·i±iÐATÔUÜ˜$Ÿ,™,¨¯	©	Õ2r    r«   r±   r®   r¯   r°   )	r²   r³   r´   rŸ   rr   r{   r€   rŒ   rÙ   rÚ   s   @r[   rl   rl   ;  s   ø„ õ=ó
ó9óJ÷3r    rl   c                  óL   ‡ — e Zd ZdZdˆ fd„Zdd„Zd	d„Zd
ˆ fd„Zdˆ fd„Zˆ xZ	S )rm   Tc                óP   •— t         ‰| �  ||«       | j                  «       | _        y rœ   r¸   r¼   s      €r[   rŸ   zDataClassBuilder.__init__o  r¾   r    c                ó   — t        | j                  j                  t        g | j                  j
                  «      | j                  j                  t        g | j                  j
                  «      «      | j                  j                  t        g | j                  j
                  «      | j                  j                  t        t        j                  t        j                  | j                  j
                  «      «      «      S )a  Set up a NonExtClassInfo to track dataclass attributes.

        In addition to setting up a normal extension class for dataclasses,
        we also collect its class attributes like a non-extension class so
        that we can hand them to the dataclass decorator.
        )r#   r�   rÅ   rD   rŽ   rc   rÒ   r2   r+   rQ   ÚtypeÚsrcrª   s    r[   rº   z$DataClassBuilder.create_non_ext_infos  s¢   € ô Ø�L‰L×Ñ¤¨R°·±·±Ó@Ø�L‰L×ÑœX b¨$¯)©)¯.©.Ó9Ó:Ø�L‰L×Ñ¤¨R°·±·±Ó@Ø�L‰L×Ñœ[¬×)<Ñ)<¼n×>PÑ>PÐRV×R[ÑR[×R`ÑR`ÓaÓbó	
ð 	
r    c                óf   — t        |j                  «      }t        |t        «      r|j                  S y rœ   )r   rö   rv   r   )rž   r’   Úann_types      r[   Úget_type_annotationz$DataClassBuilder.get_type_annotation�  s)   € ô # 4§9¡9Ó-ˆÜ�h¤Ô)Ø—=‘=Ð Ør    c                óð   •— t        | j                  | j                  ||| j                  «       t	        | j                  | j                  ||| j
                  | j                  «       t        ‰| �!  ||«       y rœ   )	rÌ   r�   r»   rú   rÍ   rŽ   r�   r¹   r€   )rž   r”   r’   r½   s      €r[   r€   zDataClassBuilder.add_attr‰  s^   ø€ Ü"Ø�L‰L˜$Ÿ,™,¨°°d×6NÑ6Nô	
ô 	Ø�L‰L˜$Ÿ,™,¨°°d·i±iÀ×ATÑATô	
ô 	‰Ñ˜ Õ&r    c                óz  •— t         ‰| �  |«       | j                  sJ ‚t        | j                  | j
                  | j                  j                  | j                  «       | j                  j                  t        d„ | j                  j                  D «       «      «      }| j                  j                  t        | j                  «      xs d«      }| j                  j                  t        || j                  | j
                  j                   | j
                  j"                  |g| j                  j                  «       y)ap  Generate code to finish instantiating a dataclass.

        This works by replacing all of the attributes on the class
        (which will be descriptors) with whatever they would be in a
        non-extension class, calling dataclass, then switching them back.

        The resulting class is an extension class and instances of it do not
        have a __dict__ (unless something else requires it).
        All methods written explicitly in the source are compiled and
        may be called through the vtable while the methods generated
        by dataclasses are interpreted and may not be.

        (If we just called dataclass without doing this, it would think that all
        of the descriptors for our attributes are default values and generate an
        incorrect constructor. We need to do the switch so that dataclass gets the
        appropriate defaults.)
        c              3  ó8   K  — | ]  }t        |«      sŒ|–— Œ y ­wrœ   )rC   )rX   Úds     r[   r\   z,DataClassBuilder.finalize.<locals>.<genexpr>ª  s   è ø€ ÒN�qÔ4JÈ1Õ4M”ÑNùs   ‚“ÚunknownN)r¹   rŒ   rÞ   Úadd_dunders_to_non_ext_dictr�   r»   rŽ   rc   Úadd_annotations_to_dicträ   ÚnextÚ
decoratorsrÕ   r?   rÅ   rK   rÀ   Úanns)rž   rZ   ÚdecÚdataclass_type_valr½   s       €r[   rŒ   zDataClassBuilder.finalize’  sà   ø€ ô$ 	‰Ñ˜ÔØ�}Š}Ðˆ}Ü#Ø�L‰L˜$Ÿ,™,¨¯	©	¯©¸×8TÑ8Tô	
ð �l‰l×!Ñ!ÜÑN˜DŸI™I×0Ñ0ÔNÓNó
ˆð "Ÿ\™\×2Ñ2´>À$Ç)Á)Ó3LÒ3YÐPYÓZÐØ�‰×ÑÜ%Ø�$—-‘- §¡×!2Ñ!2°D·L±L×4EÑ4EÐGYÐZØ�I‰I�N‰Nõ	
r    r«   rØ   ©r’   r
   r¬   zTypeInfo | Noner¯   r°   )
r²   r³   r´   r  rŸ   rº   rú   r€   rŒ   rÙ   rÚ   s   @r[   rm   rm   i  s)   ø„ ð #Ðõ2ó
óõ'÷
ñ 
r    rm   c                  ó   — e Zd ZdZdZdd„Zy)rn   aS  Create IR for an attrs class where auto_attribs=False (the default).

    When auto_attribs is enabled, attrs classes behave similarly to dataclasses
    (i.e. types are stored as annotations on the class) and are thus handled
    by DataClassBuilder, but when auto_attribs is disabled the types are
    provided via attr.ib(type=...)
    Fc                ó  — t        |j                  t        «      ræ|j                  j                  }t        |t        «      rÀ|j
                  dv r²d|j                  j                  v rš|j                  j                  j                  d«      }|j                  j                  |   }t        |t        «      rLt        |j                  t        «      r2|j                  d   }t        |t        «      sJ |«       ‚|j                  S y )N)zattr.ibz	attr.attrrö   r   )rv   râ   r   Úcalleer   rj   Ú	arg_namesÚindexÚargsr   r‚   r   r   )rž   r’   r
  r  Ú	type_namer”   s         r[   rú   z%AttrsClassBuilder.get_type_annotation¿  s½   € Ü�d—k‘k¤8Ô,à—[‘[×'Ñ'ˆFä˜6¤:Ô.Ø—O‘OÐ'?Ñ?Ø˜dŸk™k×3Ñ3Ñ3àŸ™×-Ñ-×3Ñ3°FÓ;�Ø ŸK™K×,Ñ,¨UÑ3�	Ü˜i¬Ô2´zÀ)Ç.Á.ÔRZÔ7[Ø!Ÿ\™\¨!™_�FÜ% f¬hÔ7Ð?¸Ó?Ð7Ø$Ÿ>™>Ð)Ør    Nr  )r²   r³   r´   rµ   r  rú   r¢   r    r[   rn   rn   ´  s   „ ñð $Ðôr    rn   c                óä  — |j                   |j                  z   }|j                  }|r$t        | |j                  ||j
                  «      g}ng }|s|rK|j                  |D �cg c]  }| j                  |«      ‘Œ c}«       | j                  ||j
                  «      }n | j                  t        t        d¬«      «      }| j                  | j                  «      }| j                  t        t        |j                  dz   | j                  t         «      «      }| j#                  t$        |||g|j
                  «      }	| j'                  |	|j
                  «       | j(                  j*                  |j,                     }
|
j.                  s|
j0                  ss| j                  t3        t5        |j                  dz   d | j                  t7        g t8        «      «      g |j
                  «      «       | j;                  |j                  |	«       | j=                  t>        |	| j                  d«      tA        | | j(                  j*                  |j,                     |j
                  «      g|j
                  «       | j                  tC        |	|j                  | j                  t         «      «       | j#                  tD        | jG                  «       | j                  |j                  «      |	g|j
                  «       |	S c c}w )NT)Úis_borrowedÚ	_templateÚ_trait_vtable_setupÚ__mypyc_attrs__)$Úbase_type_exprsÚremoved_base_type_exprsÚ	type_argsÚmake_generic_base_classrj   rc   Úextendrä   Ú	new_tuplerÒ   r,   r7   rÕ   rÓ   r-   rw   r&   rÅ   rP   rÑ   r`   ra   r_   r†   Úbuiltin_baser)   r$   r%   r5   Úadd_coroutine_setup_callrå   rJ   Úcreate_mypyc_attrs_tupler*   rE   rÔ   )r�   rŽ   Ú
base_exprsÚnew_style_type_argsÚbasesÚxÚtp_basesÚmodnameÚtemplateÚtprZ   s              r[   rÝ   rÝ   Ñ  sb  € à×%Ñ%¨×(DÑ(DÑD€JØŸ.™.ÐÙÜ(¨°$·-±-ÐATÐVZ×V_ÑV_Ó`Ða‰àˆáÑ(Ø�‰°Ö<¨A�g—n‘n QÕ'Ò<Ô=Ø×$Ñ$ U¨D¯I©IÓ6‰à—;‘;œ~Ô.?ÈTÔRÓSˆØ×Ñ˜w×2Ñ2Ó3€GØ�{‰{ÜÔ$ d§i¡i°+Ñ&=¸w×?RÑ?RÔTbÓcó€Hð 
�‰Ô/°(¸HÀgÐ1NÐPT×PYÑPYÓ	Z€Bð ×)Ñ)¨"¨d¯i©iÔ8ð 
�‰×	"Ñ	" 4§9¡9Ñ	-€BØ�;Š;˜rŸšØ�‰ÜÜØ—I‘IÐ 5Ñ5ØØ×'Ñ'Ü! "¤oÓ6ó	ð Ø—	‘	ó	ô	
ð 	×(Ñ(¨¯©°BÔ7ð ×ÑÜàØ×ÑÐ.Ó/Ü$ W¨g¯n©n×.GÑ.GÈÏ	É	Ñ.RÐTX×T]ÑT]Ó^ð	
ð
 	�	‰	ôð ‡K�K”
˜2˜tŸy™y¨'×*=Ñ*=¼~ÓNÔOð ‡N�NÜØ	×	"Ñ	"Ó	$ g×&6Ñ&6°t·y±yÓ&AÀ2ÐFØ�	‰	ôð €Iùòk =s   Á!K-c                óè  — | j                  t        | j                  d«      g|«      }t        | |||«      }g }t	        ||«      D ]Y  \  }}|j
                  t        k(  r0| j                  t        |g|«      }	| j                  t        |	g|«      }|j                  |«       Œ[ | j                  |d|«      }
t        |«      dk(  r|d   }n| j                  ||«      }| j                  t        |
|g|«      }|S )zUConstruct Generic[...] base class object for a new-style generic class (Python 3.12).Ú_typingÚGenericrU   r   )rÅ   rL   rÕ   r9   ÚzipÚkindr	   rå   rF   rG   rˆ   Úpy_get_attrrf   r  rH   )r�   rj   r  rc   ÚmodÚtvsr  ÚtvÚ
type_paramÚitÚgentÚargrW   s                r[   r  r    sî   € ð �.‰.œ W×%5Ñ%5°iÓ%@Ð$AÀ4Ó
H€CÜ
˜W c¨9°dÓ
;€CØ€DÜ˜c 9Ó-ò ‰ˆˆJØ�?‰?Ô1Ò1à×%Ñ%¤g°¨t°TÓ:ˆBØ—‘¤¨"¨¨tÓ4ˆBØ�‰�B�ðð ×Ñ˜s I¨tÓ4€DÜ
ˆ4ƒy�A‚~Ø�1‰g‰à×Ñ  dÓ+ˆà×Ñ¤°°s°¸TÓB€DØ€Kr    )ztyping._TypedDictztyping_extensions._TypedDictzFinal[tuple[str, ...]]ÚMAGIC_TYPED_DICT_CLASSESc                óô  — |j                   j                  }| j                  j                  |j                      }g }d„ |j                   j                  D «       D �]�  }|j
                  dk(  rŒ|r|j
                  dv rŒ%|| j                  j                  v r@| j                  j                  |   }|j                  �|j                  j                  |«       |j
                  t        v r"d}d}| j                  |||j                  «      }	n¬|r/|j
                  dk(  r d}| j                  d||j                  «      }	n{|j
                  j                  dd	«      d
   }
|
| j                  k(  r'| j                  |j                  |j                  «      }	n&| j                  |j
                  |j                  «      }	|j                  |	«       |j
                  t        v s�Œ‚ n | j!                  ||j                  «      S )zmCreate base class tuple of a non-extension class.

    The tuple is passed to the metaclass constructor.
    c              3  ó4   K  — | ]  }|j                   –— Œ y ­wrœ   )rö   )rX   Úbs     r[   r\   z)populate_non_ext_bases.<locals>.<genexpr>;  s   è ø€ Ò0˜1�—•Ñ0ùs   ‚zbuiltins.object)ztyping.Sequenceztyping.Iterableztyping.Collectionztyping.Reversibleztyping.Containerztyping.SizedÚtypingÚ
_TypedDictzbuiltins.tupleÚ_NamedTupleú.rU   r   )r_   Úis_named_tupler`   ra   r  rj   Úchildrenrˆ   r2  Úget_module_attrrc   ÚrsplitÚcurrent_moduleÚload_global_strrw   Úload_module_attr_by_fullnamer  )r�   rŽ   r:  rZ   r  ÚclsÚbase_irÚmodulerw   rW   Ú
cls_modules              r[   rÂ   rÂ   3  s«  € ð
 —Y‘Y×-Ñ-€NØ	�‰×	"Ñ	" 4§9¡9Ñ	-€BØ€EÙ0 §	¡	§¡Ô0ó &ˆØ�<‰<Ð,Ò,ØÙ˜cŸl™lð /
ñ 
ð à�'—.‘.×+Ñ+Ñ+Ø—n‘n×/Ñ/°Ñ4ˆGØ×ÑÐ+Ø× Ñ ×'Ñ'¨Ô+à�<‰<Ô3Ñ3ð ˆFØˆDØ×*Ñ*¨6°4¸¿¹ÓC‰DÙ §¡Ð0@Ò @Ø ˆDØ×*Ñ*¨8°T¸4¿9¹9ÓE‰DàŸ™×,Ñ,¨S°!Ó4°QÑ7ˆJØ˜W×3Ñ3Ò3Ø×.Ñ.¨s¯x©x¸¿¹ÓC‘à×;Ñ;¸C¿L¹LÈ$Ï)É)ÓT�Ø�‰�TÔØ�<‰<Ô3Ó3áðM&ðN ×Ñ˜U D§I¡IÓ.Ð.r    c                óè  — |j                   r| j                  |j                   «      }n¨|j                  j                  �| j	                  dd|j
                  «      S |j                  j                  r| j	                  dd|j
                  «      S | j                  t        t        j                  t        j                  |j
                  «      «      }| j                  t        ||g|j
                  «      S )z6Find the metaclass of a class from its defs and bases.r6  Ú_TypedDictMetaÚNamedTupleMeta)Ú	metaclassrä   r_   Útypeddict_typer<  rc   r:  rÒ   r+   rQ   rö   r÷   rÅ   rN   )r�   rŽ   r  Údeclared_metaclasss       r[   rÃ   rÃ   e  s»   € à‡~‚~Ø$Ÿ^™^¨D¯N©NÓ;Ñà�9‰9×#Ñ#Ð/ð ×*Ñ*¨8Ð5EÀtÇyÁyÓQÐQØ�Y‰Y×%Ò%ð ×*Ñ*¨8Ð5EÀtÇyÁyÓQÐQà$Ÿ[™[Üœ×+Ñ+¬^×-?Ñ-?ÀÇÁÓKó
Ðð �>‰>œ/Ð,>ÀÐ+FÈÏ	É	ÓRÐRr    c                óô  — | j                  t        || j                  d«      g|j                  «      }t	        t
        «      }t        «       t        «       t        «       }}}| j                  |||«       | j                  |«       | j                  |j                  «      }	| j                  |d|j                  «      }
| j                  |
|	|g|j                  «      }| j                  |||j                  «       | j                  |«       | j                  |«       | j                  || j                  t        g |j                  «      |j                  «       | j                  |«       | j                  |«       |S )z‚Initialize the class dictionary for a non-extension class.

    This class dictionary is passed to the metaclass constructor.
    Ú__prepare__)rå   rI   rÕ   rc   r/   r6   r'   Úadd_bool_branchÚactivate_blockrw   r*  Úpy_callÚassignÚgotorÅ   rD   )r�   rŽ   rH  r  Úhas_preparerÈ   Ú
true_blockÚfalse_blockÚ
exit_blockÚcls_nameÚprepare_methÚprepare_dicts               r[   rÄ   rÄ   z  s(  € ð ×&Ñ&Ü˜	 7×#3Ñ#3°MÓ#BÐCÀTÇYÁYó€Kô œOÓ,€Lä*4«,¼
»ÄjÃl˜Z�€JØ×Ñ˜K¨°[ÔAà×Ñ˜:Ô&Ø×Ñ §	¡	Ó*€HØ×&Ñ& y°-ÀÇÁÓK€LØ—?‘? <°(¸EÐ1BÀDÇIÁIÓN€LØ‡N�N�< ¨t¯y©yÔ9Ø‡L�L�Ôà×Ñ˜;Ô'Ø‡N�N�< §¡´¸RÀÇÁÓ!KÈTÏYÉYÔWØ‡L�L�ÔØ×Ñ˜:Ô&àÐr    Nc                ój  — d}|�z ||«      }|rp| j                   |j                  k(  r5|j                  |j                  k  r| j                  |j                  «      }n"t        | ||j                  |j                  «      }|€êt        |j                  «      }t        |j                  t        «      r<|j                  j                  �&| j                  |j                  j                  «      }nt        |t        «      r-t        | |j                  |j                  |j                  «      }nB| j                  t        t        j                  t        j                   |j                  «      «      }| j                  |j"                  «      }| j%                  t&        |j(                  ||g|j                  «       y)zBAdd a class attribute to __annotations__ of a non-extension class.N)r>  rÓ   rc   rÕ   rj   r>   Úunanalyzed_typer   rö   rv   r   Úoriginal_str_exprr   rÒ   r+   rQ   r÷   rw   rÅ   rE   r  )	r�   r»   r”   r’   Úget_type_inforè   Ú	type_inforù   Úkeys	            r[   rÌ   rÌ   š  sJ  € ð €CØÐ Ù! $Ó'ˆ	Ùð ×%Ñ%¨×)>Ñ)>Ò>À4Ç9Á9ÈyÏ~É~ÒC]Ø×&Ñ& y×'9Ñ'9Ó:‘ä ¨°D×4HÑ4HÈ$Ï)É)ÓT�à
€{ä" 4§9¡9Ó-ˆä�t×+Ñ+¬[Ô9Ø×$Ñ$×6Ñ6ÐBð ×"Ñ" 4×#7Ñ#7×#IÑ#IÓJ‰CÜ˜¤(Ô+Ü˜G X§]¡]°D×4HÑ4HÈ$Ï)É)ÓT‰Cà—+‘+œk¬.×*=Ñ*=¼~×?QÑ?QÐSW×S\ÑS\Ó]Ó^ˆCà
×
Ñ
˜6Ÿ;™;Ó
'€CØ‡N�NÔ)¨G¯L©L¸#¸sÐ+CÀTÇYÁYÕOr    c                óž  — t        |j                  t        «      s³| j                  |j                  «      }| j	                  ||j
                  ||j                  «       |j                  j                  rY|j                  j                  d   j                  j                  r+|j
                  t        vr|j                  |t        f«       yyyyy)z;Add a class attribute to __dict__ of a non-extension class.éÿÿÿÿN)rv   râ   r   rä   Úadd_to_non_ext_dictrw   rc   r_   r  rö   Úis_enumr   rˆ   r7   )r�   r»   r”   r’   rŽ   Úattr_to_cacherâ   s          r[   rÍ   rÍ   È  s    € ô �d—k‘k¤8Ô,Ø—‘ §¡Ó,ˆØ×#Ñ# G¨V¯[©[¸&À$Ç)Á)ÔLð �I‰I�OŠOà—	‘	—‘ Ñ#×(Ñ(×0Ò0à—‘Ô#;Ñ;ð × Ñ  &Ô*;Ð!<Õ=ð <ð 1ð ð -r    c                ó   — | j                   j                  |j                     }|j                  rt	        «       g fS t	        «       }g }| j
                  j                  r|j                  g}n(t        t        |j                  j                  «      «      }|D ]³  }| j                   j                  j                  |«      }|€Œ+t        |j                  «      }|j                  j                  j                  D ]Q  }	t        |	t         «      sŒt#        |	||«      }
|
€Œ$|j%                  |
«       |j'                  |	|j(                  f«       ŒS Œµ ||fS )a‘  Find initializers of attributes in a class body.

    Under separate compilation, only this class's own body is walked, and
    generate_attr_defaults_init emits a runtime call to the parent's
    __mypyc_defaults_setup so inherited defaults are produced by chaining,
    not by inlining. Walking the MRO here would break under separate=True
    with mypy's incremental cache: a base class loaded from the cache has
    an empty ClassDef.defs.body (mypy/nodes.py::ClassDef.serialize doesn't
    serialize the class body), so inherited assignments would be silently
    dropped and the subclass's __mypyc_defaults_setup would leave inherited
    slots in the "undefined" state at runtime.

    Without separate compilation, all modules are parsed in the same pass
    and the MRO walk is safe; we keep the original inline-all behavior
    there as an optimization (no chain call needed for instance creation).
    )r`   ra   r_   r  Úsetrë   rì   ÚlistÚreversedrh   Úgetr?   Údefnrt   ru   rv   r
   r@   rÒ   rˆ   rÓ   )r�   rŽ   rA  rî   rò   Úinfosr_   Úinfo_irÚinfo_cls_typer’   rw   s              r[   rí   rí   ã  s(  € ð& �.‰.×
#Ñ
# D§I¡IÑ
.€CØ
×ÒÜ‹u�bˆyÐä$'£EÐØ<>Ðð ‡�×ÒØ!%§¡ ‰ä”X˜dŸi™iŸm™mÓ,Ó-ˆàò AˆØ—.‘.×+Ñ+×/Ñ/°Ó5ˆØˆ?ØÜ& t§y¡yÓ1ˆØ—I‘I—N‘N×'Ñ'ò 	AˆDÜ˜d¤NÔ3ØÜ$ T¨7°MÓBˆDØˆ|ØØ×#Ñ# DÔ)Ø×&Ñ&¨¨d×.>Ñ.>Ð'?Õ@ñ	AðAð Ð 3Ð3Ð3r    c           	     óè  — | j                   j                  |j                     }|j                  ryd}| j                  j
                  r*|j                  dd D ]  }t        |j                  v sŒ|} n |s|€y| j                  |t        t        «      5  | j                  «       }|�Î|j                  t        «      }| j                  j                  ||gt        gdg|j                   «      }t#        «       t#        «       }
}	| j%                  t'        ||
|	t&        j(                  «      «       | j+                  |	«       | j%                  t-        | j/                  «       «      «       | j+                  |
«       |D �]1  \  }}|j0                  d   }t3        |t4        «      sJ |«       ‚|j6                  s;t9        |j:                  «      s&| j=                  d|j:                  j                   «       |j?                  |j@                  «      }|| jB                  k7  r|nd| _"        	 | jG                  | jI                  |j:                  «      ||j                   «      }d| _"        tK        ||j@                  ||j:                  j                   «      }|jM                  «        | j%                  |«       �Œ4 | j%                  t-        | jO                  «       «      «       ddd«       y# d| _"        w xY w# 1 sw Y   yxY w)ai  Generate an initialization method for default attr values (from class vars).

    Under separate compilation, the emitted __mypyc_defaults_setup chains to
    the nearest ancestor that has the method (Python __init__ style), then
    sets only this class's own defaults; inherited defaults are produced by
    the chain at runtime. The ancestor lookup uses cls.mro[1:] and relies on
    prepare.py having registered the FuncDecl on every class that needs one
    before any IR build runs. IR build within a compilation group proceeds
    in filename order, so this class may be IR-built before its base, and a
    method_decls lookup that depended on the base having been IR-built first
    would miss. Without separate compilation, find_attr_initializers has
    already collected the full MRO's defaults into default_assignments, so
    we inline them all as before.
    NrU   r   z#Unsupported default attribute value)(r`   ra   r_   r  rë   rì   rh   r    rƒ   Úenter_methodr5   rž   Úmethod_declr�   Úcallr   rc   r'   rÒ   r(   ÚBOOLrN  r0   Úfalser   rv   r   r�   rB   râ   ÚwarningÚ	attr_typerw   rÓ   Úglobals_lookup_moduleÚcoercerä   r1   Úmark_as_initializerÚtrue)r�   rŽ   rò   rA  Úparent_with_defaultsÚancestorÚself_varrŠ   Ú	parent_okÚ
fail_blockÚcontinue_blockr’   Úorigin_moduler”   rt  ÚvalÚinits                    r[   rð   rð     sk  € ð" �.‰.×
#Ñ
# D§I¡IÑ
.€CØ
×ÒØà+/ÐØ‡�×ÒØŸ™  ˜ò 	ˆHÜ# x×'<Ñ'<Ò<Ø'/Ð$Ùð	ñ
 Ð#7Ð#?Øà	×	Ñ	˜cÔ#7¼Ó	Iñ $,Ø—<‘<“>ˆð
  Ð+Ø'×3Ñ3Ô4HÓIˆDØŸ™×,Ñ,¨T°H°:Ä¸yÈ4È&ÐRV×R[ÑR[Ó\ˆIÜ)3«´z³|˜ˆJØ�K‰Kœ˜y¨.¸*ÄfÇkÁkÓRÔSØ×"Ñ" :Ô.Ø�K‰Kœ˜wŸ}™}›Ó/Ô0Ø×"Ñ" >Ô2à#6ó 	ÑˆD�-Ø—\‘\ !‘_ˆFÜ˜f¤hÔ/Ð7°Ó7Ð/Ø×$Ò$¬[¸¿¹Ô-EØ—‘Ð EÀtÇ{Á{×GWÑGWÔXàŸ™ f§k¡kÓ2ˆIð
 "/°'×2EÑ2EÒ!E‘È4ð Ô)ð5Ø—n‘n W§^¡^°D·K±KÓ%@À)ÈTÏYÉYÓW�à04�Ô-Ü˜8 V§[¡[°#°t·{±{×7GÑ7GÓHˆDØ×$Ñ$Ô&Ø�K‰K˜Öð'	ð* 	�‰”F˜7Ÿ<™<›>Ó*Ô+÷I$,ð $,øð> 15�Õ-ú÷?$,ð $,ús&   ÂF
K(È6KÉA?K(Ë	K%Ë%K(Ë(K1c                óÀ   — | j                   j                  |j                     }|j                  d«      r*|j                  d«      st	        | ||j
                  «       yyy)zHCreate a "__ne__" method from a "__eq__" method (if only latter exists).Ú__eq__Ú__ne__N)r`   ra   r_   Ú
has_methodÚgen_glue_ne_methodrc   )r�   rŽ   rA  s      r[   rñ   rñ   Z  sJ   € à
�.‰.×
#Ñ
# D§I¡IÑ
.€CØ
‡~�~�hÔ¨¯©°xÔ(@Ü˜7 C¨¯©Õ3ð )AÐr    c                óÄ  — |j                  d«      }| j                  j                  }| j                  |d|j                  «      5  |j
                  d   j                  }| j                  d|«      }| j                  t        | j                  «       d|g|«      «      }t        t        j                  |j                  «      }t        |j                  t        «      }	|r|�rt        «       t        «       }}
| j                  t        t        j                  t        j                   |«      «      }| j                  t#        | j%                  ||d|«      |
|t"        j&                  «      «       | j)                  |«       |	r|rt        nt*        }| j-                  | j.                  j1                  ||d¬«      ||«      }| j                  t3        |«      «       | j)                  |
«       | j                  t3        |«      «       nN|	r|rt        nt*        }| j-                  | j5                  |d|«      ||«      }| j                  t3        |«      «       d	d	d	«       y	# 1 sw Y   y	xY w)
z2Generate a "__ne__" method from a "__eq__" method.rƒ  r„  rU   ÚrhsÚisT)Úlikely_boolÚnotN)Ú
method_sigrë   Ústrict_dunders_typingrn  Úret_typer  rö   Úadd_argumentrÒ   r.   rž   rR   rM   r5   r'   r+   r÷   r(   Útranslate_is_oprq  rN  r7   rv  r�   Ú	unary_notr0   Úunary_op)r�   rA  rc   Úeq_sigÚstrict_typingÚrhs_typeÚrhs_argÚeqvalÚcan_return_not_implementedÚreturn_boolÚnot_implemented_blockÚregular_blockÚnot_implementedÚrettypeÚretvals                  r[   r†  r†  a  sä  € à�^‰^˜HÓ%€FØ—O‘O×9Ñ9€MØ	×	Ñ	˜c 8¨V¯_©_Ó	=ñ !(Ø—;‘;˜q‘>×&Ñ&ˆØ×&Ñ& u¨hÓ7ˆØ—‘œJ w§|¡|£~°xÀ'ÀÈDÓQÓRˆä%/Ô0B×0GÑ0GÈÏÉÓ%YÐ"Ü  §¡´/ÓBˆáÒ :ä3=³<ÄÃ =Ð!Ø%Ÿk™kÜÔ.×3Ñ3Ô5G×5KÑ5KÈTÓRóˆOð �K‰KÜØ×+Ñ+¨E°?ÀDÈ$ÓOØ)Ø!Ü—K‘Kó	ôð ×"Ñ" =Ô1Ù)4¹•oÔL]ˆGØ—^‘^Ø—‘×)Ñ)¨%°À4Ð)ÓHÈ'ÐSWóˆFð �K‰Kœ˜v›Ô'Ø×"Ñ"Ð#8Ô9Ø�K‰Kœ˜Ó/Õ0á)4¹•oÔL]ˆGØ—^‘^ G×$4Ñ$4°U¸EÀ4Ó$HÈ'ÐSWÓXˆFØ�K‰Kœ˜v›Ô'÷C!(÷ !(ñ !(ús   ÁHIÉIc                ó¾   — | j                  |j                  «      }t        | ||«       | j                  |j                  ||j
                  |j                  g|«      }|S rœ   )rÕ   rw   r   rO  rH  r  rÀ   )r�   rZ   r»   rc   rV  Úclass_type_objs         r[   rÏ   rÏ   ‰  sV   € ð ×Ñ §¡Ó(€Hä ¨°$Ô7à—_‘_Ø×Ñ˜H g§m¡m°W·\±\ÐBÀDó€Nð Ðr    c                óâ   — |j                   }|}t        |«      D ]R  }|j                  | j                  «      }t	        |t
        «      sJ |«       ‚| j                  ||g|j                  «      }ŒT |S )am  Apply class decorators to create a decorated (non-extension) class object.

    Given a decorated ClassDef and a register containing a
    non-extension representation of the ClassDef created via the type
    constructor, applies the corresponding decorator functions on that
    decorated ClassDef and returns a register containing the decorated
    ClassDef.
    )r  rg  rä   Úvisitorrv   r3   rO  rc   )r�   rŽ   rÞ   r  Ú	dec_classrþ   Ú	decorators          r[   rÐ   rÐ   –  so   € ð —‘€JØ€IÜ�jÓ!ò LˆØ—H‘H˜WŸ_™_Ó-ˆ	Ü˜)¤UÔ+Ð6¨YÓ6Ð+Ø—O‘O I°	¨{¸I¿N¹NÓK‰	ðLð Ðr    c                ó  — | j                  |j                  j                  «      }|D ]b  \  }}t        |t        «      sJ |«       ‚| j                  ||j                  |j                  «      }| j                  |||j                  |¬«       Œd y)z6Add class attributes to be cached to the global cache.)Útype_overrideN)	rã   r_   rj   rv   r   r*  rw   rc   rç   )r�   r�   rŽ   rè   ÚlvalÚrtypeÚrvals          r[   rÖ   rÖ   ¨  s   € ð ×
)Ñ
)¨$¯)©)×*<Ñ*<Ó
=€CØ%ò N‰ˆˆeÜ˜$¤Ô)Ð/¨4Ó/Ð)Ø×"Ñ" 3¨¯	©	°4·9±9Ó=ˆØ×!Ñ! $¨¨d¯i©iÀuÐ!ÕMñNr    c                ó
  — |j                   D ��cg c]  }|j                  D ]  }|‘Œ Œ }}}|j                  r|j                  d«       |D �cg c]  }| j	                  |«      ‘Œ }}| j                  ||«      S c c}}w c c}w )NÚ__dict__)rh   Ú
attributesÚinherits_pythonrˆ   rÕ   r  )r�   rZ   rc   rz  rw   Úattrsr^   ry   s           r[   r  r  ³  s|   € Ø"$§&¡&×I�h°X×5HÑ5HÒI¨TŠTÐIˆTÐI€EÑIØ	×ÒØ�‰�ZÔ Ø05Ö6¨ˆW×Ñ˜dÕ#Ð6€EÐ6Ø×Ñ˜U DÓ)Ð)ùó	 Jùò 7s   �A:ÁB c                óè   — |r| j                  |d|j                  |«       d}| j                  |d| j                  |«      |«       | j                  |d| j                  | j                  «      |«       y )NÚ__annotations__zmypyc filler docstringrµ   r³   )ra  r  rÕ   rÓ   )r�   r»   rc   Úadd_annotationsÚfiller_doc_strs        r[   r   r   »  sm   € ñ à×#Ñ# GÐ->ÀÇÁÈdÔSð
 .€NØ×Ñ ¨°G×4DÑ4DÀ^Ó4TÐVZÔ[Ø×Ñ ¨°w×7GÑ7GÈ×H[ÑH[Ó7\Ð^bÕcr    r«   )r�   r8   rŽ   r   r¬   r3   )
r�   r8   rj   Ústrr  zlist[TypeParam]rc   Úintr¬   r3   )r�   r8   rŽ   r   r  r3   r¬   r3   )
r�   r8   rŽ   r   rH  r3   r  r3   r¬   r3   rœ   )r�   r8   r»   r#   r”   r   r’   r
   r\  z2Callable[[AssignmentStmt], TypeInfo | None] | Noner¬   r­   )r�   r8   r»   r#   r”   r   r’   r
   rŽ   r   rc  úlist[tuple[Lvalue, RType]]r¬   r­   )r�   r8   rŽ   r   r¬   z1tuple[set[str], list[tuple[AssignmentStmt, str]]])r�   r8   rŽ   r   rò   z list[tuple[AssignmentStmt, str]]r¬   r­   )r�   r8   rA  r"   rc   r´  r¬   r­   )
r�   r8   rZ   r"   r»   r#   rc   r´  r¬   r3   )r�   r8   rŽ   r   rÞ   r3   r¬   r3   )r�   r8   r�   rµ  rŽ   r   r¬   r­   )r�   r8   rZ   r"   rc   r´  r¬   r3   )T)
r�   r8   r»   r#   rc   r´  r±  Úboolr¬   r­   ){rµ   Ú
__future__r   Úabcr   Úcollections.abcr   r6  r   Ú
mypy.nodesr   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Ú
mypy.typesr   r   r   Úmypyc.commonr   r    r!   Úmypyc.ir.class_irr"   r#   Úmypyc.ir.func_irr$   r%   Úmypyc.ir.opsr&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   Úmypyc.ir.rtypesr4   r5   r6   r7   Úmypyc.irbuild.builderr8   r9   Úmypyc.irbuild.functionr:   r;   r<   r=   r>   Úmypyc.irbuild.utilr?   r@   rA   rB   rC   Úmypyc.primitives.dict_opsrD   rE   Úmypyc.primitives.generic_opsrF   rG   rH   rI   rJ   Úmypyc.primitives.misc_opsrK   rL   rM   rN   rO   rP   rQ   Úmypyc.subtyperR   r˜   rš   rp   rl   rm   rn   rÝ   r  r2  r°  rÂ   rÃ   rÄ   rÌ   rÍ   rí   rð   rñ   r†  rÏ   rÐ   rÖ   r  r   r¢   r    r[   ú<module>rÈ     sè  ðÚ ?å "å Ý $Ý ÷÷ ÷ ÷ ÷ õ ÷. >Ñ =ß TÑ Tß 6ß 4÷÷ ÷ ÷ ÷  WÓ Vß ?÷õ ÷õ ÷ J÷õ ÷÷ ñ õ %óG÷Tñ ô@6H˜ô 6Hôr+3�lô +3ô\H
�ô H
ôVÐ(ô ó:?ðDØðØ"%ðØ2AðØILðà
óð44Ð Ð0ó ó//ódSð*ØðØ&ðØ38ðØAFðà
óðJ IMð+PØð+Pàð+Pð ð+Pð ð	+Pð
 Fð+Pð 
ó+Pð\>Øð>àð>ð ð>ð ð	>ð
 ð>ð .ð>ð 
ó>ð6.4Øð.4Ø&ð.4à6ó.4ðbC,ØðC,Ø&ðC,Ø=]ðC,à	óC,óL4ó%(ðP
Øð
Ø#ð
Ø.=ð
ØEHð
à
ó
óð$NØðNØ(BðNØJRðNà	óNó*ð VZðdØðdØ!0ðdØ8;ðdØNRðdà	ôdr    