
    X-Ph\                       d dl mZ d dl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 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 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+ d dl,m-Z- d;dZ.d;dZ/d<dZ0d=dZ1d>d$Z2d?d)Z3 G d* d+e          Z4d@d1Z5 G d2 d3e          Z6dAd5Z7 G d6 d7          Z8dBd:Z9dS )C    )annotationsN)defaultdict)
cmp_to_key)Callable)State)format_type)PYTHON_EXTENSIONS)LDEF	Decorator
ExpressionFuncBase
MemberExprMypyFileNodeOverloadedFuncDefRefExpr
SymbolNodeTypeInfoVar)FineGrainedBuildManager)ExtendedTraverserVisitor)tuple_fallback)	FunctionLikeInstanceLiteralType
ProperType	TupleTypeTypedDictTypeTypeVarType	UnionTypeget_proper_type)fill_typevars_with_anyor   lineintcolumnreturnboolc                D    | j         |k    p| j         |k    o
| j        |k    S N)r$   r&   r#   r$   r&   s      P/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypy/inspections.pynode_starts_afterr-   *   s%    6D=@AFdN@qx&/@@    c                h    | j         *| j        #| j         |k     s| j         |k    r| j        |k     rdS dS )NTF)end_line
end_columnr+   s      r,   node_ends_beforer2   .   sB     	z!,"::
d 2 2q|f7L7L45r.   exprr   strc                J    | j          d| j        dz    d| j         d| j         S )z1Format expression span as in mypy error messages.:   )r$   r&   r0   r1   )r3   s    r,   	expr_spanr8   7   s2    iMM$+/MMDMMMDOMMMr.   typr   list[Instance]c                   t          | t                    r| gS t          | t                    rt          |           gS t          | t                    r| j        gS t          | t                    r| j        gS t          | t                    r| j        gS t          | t                    re| j	        r=g }| j	        D ]1}|
                    t          t          |                               2|S t          t          | j                            S t          | t                    r=g }| j        D ]1}|
                    t          t          |                               2|S g S )zBReturns the Instance fallback for this type if one exists or None.)
isinstancer   r   r   r   fallbackr   r   r   valuesextendget_instance_fallbackr!   upper_boundr    items)r9   rests      r,   r@   r@   <   sc   #x   u	C	#	# s##$$	C	'	' ~	C	&	& ~	C	%	% ~	C	%	% : 	CZ F F

01C1CDDEEEEJ$_S_%E%EFFF	C	#	#  	B 	BAJJ,_Q-?-?@@AAAA
Ir.   nameinfor   Var | FuncBase | Nonec                p   |                     |           }|rgt          |t                    r|j        S |j        rBt          |t
                    sJ |j        d         }t          |t                    sJ |j        S |S |                    |           }|r|j        nd}t          |t                    r|S dS )z7Find the node defining member 'name' in given TypeInfo.r   N)

get_methodr<   r   varis_propertyr   rB   getnoder   )rE   rF   methoddecrM   vs         r,   	find_noderQ   W   s     __T""F fi(( 	: 	f&788888,q/Cc9-----7N xx~~'DII4a 	H4r.   fullnamemodulesdict[str, State]State | Nonec                    | }||v r||         S 	 d|vrdS |                     dd          \  }}|                    |          }||S :)znFind module by a node fullname.

    This logic mimics the one we use in fixup, so should be good enough.
    T.Nr7   maxsplit)rsplitrL   )rR   rS   headtailmods        r,   find_module_by_fullnamer^   m   sj    
 D wt}d??4[[q[11
dkk$?Jr.   c                  "    e Zd ZdZdd	ZddZdS )SearchVisitorzGVisitor looking for an expression whose span matches given one exactly.r$   r%   r&   r0   r1   r'   Nonec                L    || _         || _        || _        || _        d | _        d S r*   )r$   r&   r0   r1   result)selfr$   r&   r0   r1   s        r,   __init__zSearchVisitor.__init__   s)    	 $)-r.   r#   r   r(   c                @   t          || j        | j                  rdS t          || j        | j                  rdS |j        | j        k    rL|j        | j        k    r<|j        | j        k    r,|j        | j        k    rt          |t                    r|| _        | j        d u S )NF)	r-   r$   r&   r2   r0   r1   r<   r   rc   rd   r#   s     r,   visitzSearchVisitor.visit   s    Q	4;77 	5At}do>> 	5Fdi
dm++DK''//!Z((  {d""r.   N)
r$   r%   r&   r%   r0   r%   r1   r%   r'   ra   r#   r   r'   r(   __name__
__module____qualname____doc__re   rh    r.   r,   r`   r`      sB        QQ. . . .# # # # # #r.   r`   treer   r0   r1   Expression | Nonec                    ||k     rt          d          ||k    r||k    rt          d          t          ||||          }|                     |           |j        S )z=Find an expression matching given span, or None if not found.z$"end_line" must not be before "line"z#"end_column" must be after "column")
ValueErrorr`   acceptrc   )rp   r$   r&   r0   r1   visitors         r,   find_by_locationrv      sm     $?@@@4J&00>???D&(J??GKK>r.   c                  "    e Zd ZdZddZddZdS )SearchAllVisitorzGVisitor looking for all expressions whose spans enclose given position.r$   r%   r&   r'   ra   c                0    || _         || _        g | _        d S r*   )r$   r&   rc   )rd   r$   r&   s      r,   re   zSearchAllVisitor.__init__   s    	(*r.   r#   r   r(   c                    t          || j        | j                  rdS t          || j        | j                  rdS t	          |t
                    r| j                            |           dS )NFT)r-   r$   r&   r2   r<   r   rc   appendrg   s     r,   rh   zSearchAllVisitor.visit   si    Q	4;77 	5Aty$+66 	5a$$ 	"Kq!!!tr.   N)r$   r%   r&   r%   r'   ra   ri   rj   ro   r.   r,   rx   rx      sB        QQ+ + + +
     r.   rx   list[Expression]c                    t          ||          }|                     |           t          t          |j                            S )zFFind all expressions enclosing given position starting from innermost.)rx   rt   listreversedrc   )rp   r$   r&   ru   s       r,   find_all_by_locationr      s;    tV,,GKK(()))r.   c                      e Zd ZdZdddddddddIdZdJdZdKdZdLdZdMdZdNd#Z	dKd$Z
dOd)ZdPd,ZdQd/ZdKd0ZdRd1ZdRd2ZdSd4ZdTd>ZdUd?ZdVdBZdWdDZdXdEZdXdFZdXdGZdHS )YInspectionEnginez:Engine for locating and statically inspecting expressions.r   F)	verbositylimitinclude_spaninclude_kindinclude_object_attrsunion_attrsforce_reload
fg_managerr   r   r%   r   r   r(   r   r   r   r   r'   ra   c                   || _         || _        || _        || _        || _        || _        || _        || _        d | _        d S r*   )	r   r   r   r   r   r   r   r   module)	rd   r   r   r   r   r   r   r   r   s	            r,   re   zInspectionEngine.__init__   sL     %"
(($8!&($(r.   stater   c                V   | j         j        j        j        }d| j         j        j        _        	 | j                                          |j        J | j                             |j        |j        fgg            || j         j        j        _        dS # || j         j        j        _        w xY w)z4Reload given module while temporary exporting types.TN)r   manageroptionsexport_typesflush_cachepathupdateid)rd   r   olds      r,   reload_modulezInspectionEngine.reload_module   s    o%-:7;'4	?O''))):)))O""UXuz$:#;R@@@;>DO#+8883DO#+8>>>>s   A
B B(
expressionr   tuple[str, bool]c                    | j         j        j                            |          }||                     |          dfS t          || j         j        j        | j                  }|                     ||          dfS )zFormat type for an expression using current options.

        If type is known, second item returned is True. If type is not known, an error
        message is returned instead, and second item returned is False.
        NF)r   T)	r   r   	all_typesrL   missing_typer   r   r   add_prefixes)rd   r   	expr_typetype_strs       r,   r   zInspectionEngine.expr_type   s     O+599*EE	$$Z00%77t.6$.
 
 
   :66<<r.   r   c                    | j         j        d         j        }|J |j        d         j        }t          |t                    sJ t          |g           S )Nbuiltinsobject)r   graphrp   namesrM   r<   r   r   )rd   r   object_nodes      r,   object_typezInspectionEngine.object_type   sU    ?(49###nX.3+x00000R(((r.   	instancesr:   dict[TypeInfo, list[str]]c                b   dd}dd
}|sJ g }|D ]R}i }|j         j        }| j        s
|dd         }|D ]}t          |j                  ||<   |                    |           S ||d                   }	|dd         D ]}
|	 ||
          z  }	t          t                    }|D ]=}
|
D ]8}||v r|
|         D ](}| j        s||	v r||                             |           )9>t          |	                                t          |                    }i }|D ]}||         s||         ||<   |S )z3Collect attributes from all union/typevar variants.	attr_dictr   r'   set[str]c                \    t                      }| D ]}|t          | |                   z  }|S r*   )set)r   attrsbases      r,   
item_attrsz2InspectionEngine.collect_attrs.<locals>.item_attrs   s7    EEE! . .Yt_---Lr.   xr   yr%   c                2    | |j         v rdS || j         v rdS dS )Nr7   r   )mro)r   r   s     r,   	cmp_typesz1InspectionEngine.collect_attrs.<locals>.cmp_types  s'    AEzzqAEzzr1r.   Nr   r   r7   )key)r   r   r'   r   )r   r   r   r   r'   r%   )typer   r   sortedr   r{   r   r~   r   keysr   )rd   r   r   r   	all_attrsinstancer   r   r   intersectionitemcombined_attrsrE   sorted_basesrc   s                  r,   collect_attrszInspectionEngine.collect_attrs   s   	 	 	 		 	 	 	 	! 	$ 	$HE-#C, #2#h 1 1$TZ00dU#### "z)A,//abbM 	- 	-DJJt,,,LL %T** 	: 	:D : :>)) J : :D' :4<+?+?&t,33D999:: n1133I9N9NOOO  	0 	0D!$' )$/F4LLr.   
attrs_strs	list[str]
attrs_dictc           	         |D ]\}| j         dk     r|j        n|j        }d ||         D             }|                    d| dd                    |           d           ]d S )Nr7   c                    g | ]}d | d 	S "ro   ).0attrs     r,   
<listcomp>z4InspectionEngine._fill_from_dict.<locals>.<listcomp>6  s     >>>T[[[[>>>r.   r   z": [, ])r   rE   rR   r{   join)rd   r   r   r   cls_namer   s         r,   _fill_from_dictz InspectionEngine._fill_from_dict1  s      	E 	ED$(NQ$6$6tyyDMH>>Z-=>>>EC(CC		%0@0@CCCDDDD	E 	Er.   c           	        | j         j        j                            |          }||                     |          dfS t          |          }t          |          }|s|                                 g}|                     |          }t          |t                    rft          |j        t                    rL|j        }t          |j                  }d|v r|                    d           d|j         dd |D             i}ni }t          |t"                    rX|                                rDt'          |                                          }|                     t          |                    }	ni }	g }
|r9|D ]6}|
                    | dd                    ||                    d	           7|                     |
|	           |                     |
|           |                     d
d                    |
           d|          dfS )av  Format attributes that are valid for a given expression.

        If expression type is not an Instance, try using fallback. Attributes are
        returned as a JSON (ordered by MRO) that maps base class name to list of
        attributes. Attributes may appear in multiple bases if overridden (we simply
        follow usual mypy logic for creating new Vars etc).
        NF__builtins__z"<z>"c                    g | ]}d | d 	S r   ro   )r   rE   s     r,   r   z/InspectionEngine.expr_attrs.<locals>.<listcomp>T  s     0O0O0OT0O0O0Or.   z: [r   r   {}T)r   r   r   rL   r   r!   r@   r   r   r<   r   rM   r   r   r   removerR   r   is_type_objr"   type_objectr{   r   r   r   )rd   r   r   r   r   rM   r   mod_dicttemplate
class_dict
base_attrsr]   s               r,   
expr_attrszInspectionEngine.expr_attrs9  s)    O+599*EE	$$Z00%77#I..	))44	 	-))++,I''	22
 j'** 	z*/8/T/T 	?D4:&&E&&^,,,.T]...0O0O0O0O0OPHHH i.. 	93H3H3J3J 	-i.C.C.E.EFFH++,A(,K,KLLJJJ 
 	J J J!!S"H"HTYYx}-E-E"H"H"HIIIIZ444Z444  !?dii
&;&;!?!?!?LLdRRr.   r   rM   FuncBase | SymbolNoder4   c                J    |j          d|j         d|j        dz    d|j         S )Nr6   r7   )r   r$   r&   rE   )rd   r   rM   s      r,   format_nodezInspectionEngine.format_nodei  s2    +II	IIDK!OIIdiIIIr.   r   list[FuncBase | SymbolNode]c                   |j         }|6t          |t                    r|j        | j        j        j                            |j                  }|g S t          |          }t          |          }g }|D ]3}t          |j        |j                  }|r|                    |           4|st          |t                    ry|                                ret          t#          |                                                    }|D ]3}t          |j        |j                  }|r|                    |           4ng S ng S |g}|S )zCollect nodes that can be referred to by an expression.

        Note: it can be more than one for example in case of a union attribute.
        )rM   r<   r   kindr   r   r   rL   r3   r!   r@   rQ   rE   r   r{   r   r   r"   r   )rd   r   rM   	base_typer   nodesr   s          r,   collect_nodeszInspectionEngine.collect_nodesl  sg   
 .8_<*j11 jo6M O3=AA*/RR	$I ,I66	1)<<	 ) + +H$Z_hmDDD +T*** "!)\:: 
"y?T?T?V?V 
"$9293H3H3J3JKK% %	 )2 3 3H#,Z_hm#L#LD# 3 %T 2 2 23  "	" 	 FEr.   r   /tuple[dict[FuncBase | SymbolNode, State], bool]c                4   i }d}|D ]}t          |j        | j        j                  }|s |j        t
          k    r| j        r| j        }nC|||<   |j        r|j        j        s| j	        r,||j         p|j        j        z  }| 
                    |           ||fS )zGather modules where given nodes where defined.

        Also check if they need to be refreshed (cached nodes may have
        lines/columns missing).
        F)r^   rR   r   r   r   r
   r   rp   is_cache_skeletonr   r   )rd   r   r   rS   reload_neededrM   r   s          r,   modules_for_nodesz"InspectionEngine.modules_for_nodes  s      
	+ 
	+D,T]DO<QRRF ?d**t{*![FF"GDM; +&+"? +4CT +V[!QFK4QQ""6***%%r.   c                   t          |t                    sdS |                     |          }|s|                     |          dfS |                     ||          \  }}|r2|                     |          }|                     ||          \  }}|rJ g }|D ]1}|                    |                     ||         |                     2|s|                     |          dfS |                     d                    |          |          dfS )zFind and format definition location for an expression.

        If it is not a RefExpr, it is effectively skipped by returning an
        empty result.
        ) TFr   T)	r<   r   r   missing_noder   r{   r   r   r   )rd   r   r   rS   r   rc   rM   s          r,   expression_defzInspectionEngine.expression_def  s3    *g.. 	8"":.. 	8$$Z00%77!%!7!7z!J!J 	% &&z22E%)%;%;E:%N%N"G]$$$$ 	A 	ADMM$**74=$??@@@@ 	8$$Z00%77  6!2!2J??EEr.   c                N    d}| j         sd}dt          |          j         d| dS )Nr   z or try --force-reloadzNo known type available for "z" (maybe unreachable))r   r   rk   )rd   r   alt_suggestions      r,   r   zInspectionEngine.missing_type  sJ      	65N4D,<,<,E 4 4"04 4 4	
r.   c                P    dt          |          j         dt          |           S )NzCannot find definition for "z" at )r   rk   r8   )rd   r   s     r,   r   zInspectionEngine.missing_node  s.    b4
+;+;+Dbb9U_K`K`bb	
r.   rc   c                    g }| j         r(|                    t          |          j                    | j        r"|                    t          |                     |rd                    |          dz   }nd}||z   S )Nr6   z -> r   )r   r{   r   rk   r   r8   r   )rd   rc   r   prefixesprefixs        r,   r   zInspectionEngine.add_prefixes  s     	<OOtJ//8:;;; 	3OOIj11222 	XXh''&0FFFr.   rp   r   r$   r&   r0   r1   rN   (Callable[[Expression], tuple[str, bool]]dict[str, object]c                    	 t          |||dz
  ||          }n(# t          $ r}dt          |          icY d}~S d}~ww xY w|| d| d| d| }	d|	 dddS  ||          \  }
}|
d|rdnddS )	zzGet type of an expression matching a span.

        Type or error is returned as a standard daemon response dict.
        r7   errorNr6   zCan't find expression at span r   outerrstatusr   )rv   rs   r4   )rd   rp   r$   r&   r0   r1   rN   r   r   spaninspection_strsuccesss               r,    run_inspection_by_exact_locationz1InspectionEngine.run_inspection_by_exact_location  s    	')$fqj(JWWJJ 	' 	' 	'SXX&&&&&&&	' ==V==h====DBDBB2YZ[[["(&"4"4%b<OAAaPPPs    
>9>>c                   t          |||dz
            }|s| d| }d| dddS g }d}|D ]+}	 ||	          \  }
}|sd}|
r|                    |
           ,| j        r|d| j                 }d                    |          d|dS )	zGet types of all expressions enclosing a position.

        Types and/or errors are returned as a standard daemon response dict.
        r7   r6   z'Can't find any expressions at position r   r   r   N
)r   r{   r   r   )rd   rp   r$   r&   rN   expressionspositioninspection_strsr   r   r   r  s               r,   run_inspection_by_positionz+InspectionEngine.run_inspection_by_position   s     +4vzBB 	))))HKKK   % 	7 	7J&,fZ&8&8#NG  7&&~666: 	<-l
l;Oyy11"OOOr.   file&tuple[State | None, dict[str, object]]c                ,   t          fdt          D                       sdddifS t          j                                      t          fd| j        j                                        D             d          }|| _	        ||	d ddd	ni fS )
zFind module by path, or return a suitable error message.

        Note we don't use exceptions to simplify handling 1 vs 2 statuses.
        c              3  B   K   | ]}                     |          V  d S r*   )endswith)r   extr	  s     r,   	<genexpr>z/InspectionEngine.find_module.<locals>.<genexpr>%  s/      CC#4==%%CCCCCCr.   Nr   z Source file is not a Python filec              3  2   K   | ]}|j         k    |V  d S r*   )abspath)r   sabs_paths     r,   r  z/InspectionEngine.find_module.<locals>.<genexpr>+  s0      YYA19PXCXCXaCXCXCXCXYYr.   zUnknown module: r   r7   r   )
anyr	   osr   r  nextr   r   r>   r   )rd   r	  r   r  s    ` @r,   find_modulezInspectionEngine.find_module   s    
 CCCC1BCCCCC 	G'#EFFF 7??4((YYYY!6!=!=!?!?YYY[_``JO--t--bAFFF]_
 	
r.   locationc                
   	 t          |          \  }}n(# t          $ r}dt          |          icY d}~S d}~ww xY w|                     |          \  }}||sJ |S |j        r|j        j        s| j        r|                     |           |j        J t          |          dk    r&|\  }}	}
}| 	                    |j        ||	|
||          S t          |          dk    sJ |\  }}	| 
                    |j        ||	|          S )z{Top-level logic to inspect expression(s) at a location.

        This can be reused by various simple inspections.
        r   N      )parse_locationrs   r4   r  rp   r   r   r   lenr  r  )rd   r  rN   r	  posr   r   err_dictr$   r&   r0   r1   s               r,   run_inspectionzInspectionEngine.run_inspection2  sG   	'&x00ID## 	' 	' 	'SXX&&&&&&&	' **400x=OOOO z 	&UZ9 	&T=N 	&u%%%z%%%s88q==14.D&(J88
D&(J   3xx1}}}}f..uz4PPPs    
:5::c                8    |                      || j                  S )z)Get types of expression(s) at a location.)r   r   rd   r  s     r,   get_typezInspectionEngine.get_typeS  s    ""8T^<<<r.   c                8    |                      || j                  S )z.Get attributes of expression(s) at a location.)r   r   r"  s     r,   	get_attrszInspectionEngine.get_attrsW  s    ""8T_===r.   c                    |                      || j                  }d|v r/|d         s'|                    dd          \  }}d| |d<   d|d<   |S )z6Get symbol definitions of expression(s) at a location.r   r6   r7   rX   z!No name or member expressions at r   )r   r   split)rd   r  rc   _s       r,   get_definitionzInspectionEngine.get_definition[  sd    $$Xt/BCCF??6%=?"..q.99KAxJJJF5M F8r.   N)r   r   r   r%   r   r%   r   r(   r   r(   r   r(   r   r(   r   r(   r'   ra   )r   r   r'   ra   )r   r   r'   r   )r'   r   )r   r:   r'   r   )r   r   r   r   r'   ra   )r   r   rM   r   r'   r4   )r   r   r'   r   )r   r   r   r   r'   r   )r   r   r'   r4   )rc   r4   r   r   r'   r4   )rp   r   r$   r%   r&   r%   r0   r%   r1   r%   rN   r   r'   r   )
rp   r   r$   r%   r&   r%   rN   r   r'   r   )r	  r4   r'   r
  )r  r4   rN   r   r'   r   )r  r4   r'   r   )rk   rl   rm   rn   re   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r   r#  r%  r)  ro   r.   r,   r   r      s       DD ""%*!") ) ) ) ) ).	? 	? 	? 	?= = = =) ) ) )4 4 4 4lE E E E.S .S .S .S`J J J J( ( ( (T& & & &.F F F F@
 
 
 

 
 
 


 
 
 
Q Q Q Q2P P P P@
 
 
 
$Q Q Q QB= = = => > > >     r.   r   r  tuple[str, list[int]]c                ~   |                      d          dk     rt          d          |                     dd          }|^}}|                     d          dk     r|d |D             fS |                    dd          }|^}}|                     d          dk     r|d ||z   D             fS t          d          )Nr6   r  z7Format should be file:line:column[:end_line:end_column]rX   c                ,    g | ]}t          |          S ro   r%   r   ps     r,   r   z"parse_location.<locals>.<listcomp>m  s    ,,,!s1vv,,,r.   c                ,    g | ]}t          |          S ro   r-  r.  s     r,   r   z"parse_location.<locals>.<listcomp>q  s    999!s1vv999r.   )countrs   rZ   )r  partsstartrest
start_rests        r,   r  r  f  s    ~~cQRSSSOOC!O,,ELED{{3!,,t,,,,,LLqL))EEJ{{3!99zD'899999
N
O
OOr.   )r#   r   r$   r%   r&   r%   r'   r(   )r3   r   r'   r4   )r9   r   r'   r:   )rE   r4   rF   r   r'   rG   )rR   r4   rS   rT   r'   rU   )rp   r   r$   r%   r&   r%   r0   r%   r1   r%   r'   rq   )rp   r   r$   r%   r&   r%   r'   r|   )r  r4   r'   r*  ):
__future__r   r  collectionsr   	functoolsr   typingr   
mypy.buildr   mypy.messagesr   mypy.modulefinderr	   
mypy.nodesr
   r   r   r   r   r   r   r   r   r   r   r   mypy.server.updater   mypy.traverserr   mypy.typeopsr   
mypy.typesr   r   r   r   r   r   r   r    r!   mypy.typevarsr"   r-   r2   r8   r@   rQ   r^   r`   rv   rx   r   r   r  ro   r.   r,   <module>rC     s%   " " " " " " 				 # # # # # #                         % % % % % % / / / / / /                            7 6 6 6 6 6 3 3 3 3 3 3 ' ' ' ' ' '
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 1 0 0 0 0 0A A A A   N N N N
   6   ,   &# # # # #, # # #4
 
 
 
    /   $* * * *c c c c c c c cLP P P P P Pr.   