
    *e$                    $   U d Z ddlmZ ddlmZ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 ddlmZ ddlmZ ddlmZm Z m!Z!  e"d          Z#d	e$d
<    e"ddddgedddddR           Z%d	e$d<    G d d          Z&dS )zySemantic analysis of call-based Enum definitions.

This is conceptually part of mypy.semanal (semantic analyzer pass 2).
    )annotations)Finalcast)	ARG_NAMEDARG_POSMDEFAssignmentStmtCallExprContextDictExprEnumCallExpr
ExpressionListExpr
MemberExprNameExprRefExprStrExprSymbolTableNode	TupleExprTypeInfoVaris_StrExpr_list)Options)SemanticAnalyzerInterface)ENUM_REMOVED_PROPSLiteralTypeget_proper_type)z	enum.Enumzenum.IntEnumz	enum.Flagzenum.IntFlagzenum.StrEnumr   
ENUM_BASESnamevalue_name__value_
__module____annotations____doc__	__slots____dict__ENUM_SPECIAL_PROPSc                  F    e Zd Zd(dZd)dZd*dZd+dZd,dZd-d#Zd.d&Z	d'S )/EnumCallAnalyzeroptionsr   apir   returnNonec                "    || _         || _        d S N)r+   r,   )selfr+   r,   s      1lib/python3.11/site-packages/mypy/semanal_enum.py__init__zEnumCallAnalyzer.__init__:   s        sr	   is_func_scopeboolc                   t          |j                  dk    s't          |j        d         t          t          f          sdS |j        d         }|j        }|                     |j        ||          }|dS t          |t                    r|                     d|           dS | j	        
                    |||           dS )zCheck if s defines an Enum; if yes, store the definition in symbol table.

        Return True if this looks like an Enum definition (but maybe with errors),
        otherwise return False.
           r   FNz'Enum type as attribute is not supportedT)lenlvalues
isinstancer   r   r   check_enum_callrvaluefailr,   
add_symbol)r1   r5   r6   lvaluer   	enum_calls         r2   process_enum_callz"EnumCallAnalyzer.process_enum_call>   s     qy>>Qj1*?U&V&V51{((4GG	5fj)) 	II?HHH5D)Q///tr4   noder   var_namestrTypeInfo | Nonec                    t          |t                    sdS |}|j        }t          |t                    sdS |j        }|t
          vrdS |                     ||                    d          d                   \  }}}	|	s<|}
|r|
dt          |j	                  z   z  }
| 
                    |
g ||j	                  }ndt          t          |j        d                   j        }
|
|k    s|r|
dt          |j	                  z   z  }
| 
                    |
|||j	                  }|
|k    s|r| j                            |
|           t#          |||          |_        |j                            |           |j	        |_	        |S )zCheck if a call defines an Enum.

        Example:

          A = enum.Enum('A', 'foo bar')

        is equivalent to:

          class A(enum.Enum):
              foo = 1
              bar = 2
        N.@r   )r<   r
   calleer   fullnamer   parse_enum_call_argssplitrF   linebuild_enum_call_typeinfor   r   argsr    r,   add_symbol_skip_localr   analyzedset_line)r1   rD   rE   r6   callrL   rM   itemsvaluesokr   infos               r2   r=   z EnumCallAnalyzer.check_enum_callR   s    $)) 	4&'** 	4?:%%4 55dHNN3<O<OPR<STTvr 	SD -c$)nn,,00r8TYOODD1..4Dx=c$)nn,,00uh	RRD8}H**4666$T5&99t$$$I	r4   r   rW   	list[str]rM   rP   intr   c                Z   | j                             |          }|J | j                             |||          }|                                |_        d|_        |D ]M}t          |          }||_        d|_        |j	         d| |_
        t          t          |          |j        |<   N|S )NTrI   )r,   named_type_or_nonebasic_new_typeinfocalculate_metaclass_typemetaclass_typeis_enumr   rZ   is_propertyrM   	_fullnamer   r   names)	r1   r   rW   rM   rP   baserZ   itemvars	            r2   rQ   z)EnumCallAnalyzer.build_enum_call_typeinfo   s     x**844x**4t<<";;== 	: 	:Dd))CCH"CO#}55t55CM.tS99DJtr4   rV   r
   
class_name/tuple[list[str], list[Expression | None], bool]c                	   |j         }t          d |j        D                       s|                     d| d|          S t	          |          dk     r|                     d| d|          S t	          |          dk    r|                     d| d|          S g d}|j        D ] }||vr|                     d	| d
|           !d\  }}t          |j        |          D ]\  }}|dk    r|}|dk    r|}||d         }||d         }t          |t                    s|                     | d|          S g }	g }
t          |t                    rI|j	        }|
                    dd                                          D ]}|	                    |           nt          |t          t          f          r|j        }t!          |          rd |D             }	nt          d |D                       ru|D ]p}t          |t          t          f          sJ |j        \  }}t          |t                    sJ |	                    |j	                   |
                    |           qn-|                     d|z  |          S t          |t"                    rn|j        D ]d\  }}t          |t                    s|                     | d|          c S |	                    |j	                   |
                    |           ent          |d         t$                    r\t          |d         j        t(                    r;t+          |d         j        j                  }|wt          |t.                    rbt          |j	        t0                    rH|j	        }|
                    dd                                          D ]}|	                    |           n|d         j        j        rxt          |d         j        j        t0                    rS|d         j        j        }|
                    dd                                          D ]}|	                    |           n2|                     d|z  |          S |                     d|z  |          S |	s|                     | d|          S |
sdgt	          |	          z  }
t	          |	          t	          |
          k    sJ |	|
dfS )zhParse arguments of an Enum call.

        Return a tuple of fields, values, was there an error.
        c                .    g | ]}|t           t          fv S  )r   r   ).0arg_kinds     r2   
<listcomp>z9EnumCallAnalyzer.parse_enum_call_args.<locals>.<listcomp>   s"    TTTH) 44TTTr4   zUnexpected arguments to z()   zToo few arguments for    zToo many arguments for )Nr    re   modulequalnametypestartzUnexpected keyword argument "")NNr    re   Nr   r9   z1() expects a string literal as the first argument, c                    g | ]	}|j         
S rm   )r    rn   seq_items     r2   rp   z9EnumCallAnalyzer.parse_enum_call_args.<locals>.<listcomp>   s    BBBHBBBr4   c              3     K   | ]X}t          |t          t          f          o7t          |j                  d k    ot          |j        d         t
                    V  YdS )rq   r   N)r<   r   r   r:   rW   r   r{   s     r2   	<genexpr>z8EnumCallAnalyzer.parse_enum_call_args.<locals>.<genexpr>   sw          8i%:;; ;''1,;x~a0'::     r4   z>%s() with tuple or list expects strings or (name, value) pairsz-() with dict literal requires string literalszfSecond argument of %s() must be string, tuple, list or dict literal for mypy to determine Enum membersz() needs at least one itemT)rR   all	arg_kindsfail_enum_call_argr:   	arg_nameszipr<   r   r    replacerO   appendr   r   rW   r   r   r   rD   r   r   ru   r   rF   is_finalfinal_value)r1   rV   ri   rR   
valid_namearg_namer    re   argrW   rX   fieldsfield	seq_itemsr|   r   keyproper_types                     r2   rN   z%EnumCallAnalyzer.parse_enum_call_args   s    yTTT^TTTUU 	\**+Tj+T+T+TVZ[[[t99q==**+RJ+R+R+RTXYYYt99q==**+SZ+S+S+SUYZZZTTT
 	[ 	[Hz))''(S(S(S(SUYZZZ!u 66 	 	MHc7""7""=GE=GE%)) 	**PPPRV   *,eW%% ;	[FS117799 $ $U####$	8455 7	Iy)) BB	BBB   !*	      !* ) )H%hH0EFFFFF"*.KD%%dG44444LL,,,MM%(((() ..TWaa   x(( "	#k % %
U!#w// 22%TTTVZ     SY'''e$$$$% Q)) 	jas.K.K 	)$q',*;<<K'{K88 ({0#66 ( %*#^^C55;;== ( (ELL''''(a& 	:d1gl6NPS+T+T 	a1#^^C55;;== ( (ELL''''( ..| !   **x  
  	\**j+T+T+TVZ[[[ 	)Vc%jj(F5zzS[[((((fd""r4   messagecontextr   c                8    |                      ||           g g dfS )NF)r?   )r1   r   r   s      r2   r   z#EnumCallAnalyzer.fail_enum_call_arg   s$     			'7###2u}r4   msgctxc                <    | j                             ||           d S r0   )r,   r?   )r1   r   r   s      r2   r?   zEnumCallAnalyzer.fail   s    c3r4   N)r+   r   r,   r   r-   r.   )r5   r	   r6   r7   r-   r7   )rD   r   rE   rF   r6   r7   r-   rG   )
r   rF   rW   r[   rM   rF   rP   r\   r-   r   )rV   r
   ri   rF   r-   rj   )r   rF   r   r   r-   rj   )r   rF   r   r   r-   r.   )
__name__r#   __qualname__r3   rC   r=   rQ   rN   r   r?   rm   r4   r2   r*   r*   9   s              (+ + + +Z    c# c# c# c#J              r4   r*   N)'r%   
__future__r   typingr   r   
mypy.nodesr   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   mypy.optionsr   mypy.semanal_sharedr   
mypy.typesr   r   r   	frozensetr   r$   r(   r*   rm   r4   r2   <module>r      s6    
 # " " " " "                                                 * !           9 9 9 9 9 9 G G G G G G G G G G IN 
     &I	
 
 	 	 	 	 	       "D  D  D  D  D  D  D  D  D  D r4   