
    Ki>                   "   U d Z ddlmZ ddlZddlZddlZddlZddlmZm	Z	 ddl
mZ ddlmZmZ ddlZddlmZ  G d	 d
e      Z ej(                  dej*                        Z ej.                  e      Ze G d d             Ze G d d             Zi dddddddddddddddddd d!d"d#d$d%d$d&d$d'd(d)d(d*d$d+d,i d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd<dd=d>d?d>d@d>dAd(dBdCdDdEdFdGdHdIdIdIdJdJdKdLdMdMdMdNdOdPZdQedR<   i ddSgddTdUgddTdUgddTdUgddVgdg dWdg dXd(dYdZgd$d[dYgd g d\d"dUd]gd:g d>g d^d,dTd_gd.g d`d0dTdagd2g dbg dcg ddg dZgg deg g dfgdggdhdigdj
Zdkedl<   i ddmgdg dndg dndg dnddodpgddqgddpdrgd(dmgd$dmgd dpdrgd"dsdtgd:dmgd>dudvgd,dogd.dogd0dmdpgd2dmdogg dwdxgdogdogdydmgdmgg dzd{gd|gdmd}gdj
Zdked~<   i dddgddgddgddgddgddgddgd(dgd$dgd dgd"dgd:dgd>ddgd,dgd.dgd0dgd2dgdgdgg g dgg g g g ddgdj
Z dked<   i ddgdddgdddgdddgddgdddgdddgd(dgd$dgd ddgd"ddgd:dgd>g dd,dgd.dgd0ddgd2g ddgdgdgddgdgg ddgdgdgd	Z!dked<    ej(                  d       ej(                  d       ej(                  d       ej(                  d       ej(                  d       ej(                  d      gZ" ej(                  d       ej(                  d       ej(                  d       ej(                  d       ej(                  d       ej(                  d       ej(                  d       ej(                  d       ej(                  d       ej(                  d       ej(                  d      gZ# e$h d      Z% e$h d      Z&ddZ'	 d	 	 	 	 	 	 	 ddZ(ddZ) G d d      Z*y)zTree-sitter based multi-language code parser.

Extracts structural nodes (classes, functions, imports, types) and edges
(calls, inheritance, contains) from source files.
    )annotationsN)	dataclassfield)Path)
NamedTupleOptional   )TsconfigResolverc                  0    e Zd ZU dZded<   ded<   ded<   y)CellInfoz9Represents a single cell in a notebook with its language.int
cell_indexstrlanguagesourceN)__name__
__module____qualname____doc____annotations__     d/home/jay/workspace/scripts/.codegraph-venv/lib/python3.12/site-packages/code_review_graph/parser.pyr   r      s    COMKr   r   z{(?:FROM|JOIN|INTO|CREATE\s+(?:OR\s+REPLACE\s+)?(?:TABLE|VIEW)|INSERT\s+OVERWRITE)\s+((?:`[^`]+`|\w+)(?:\.(?:`[^`]+`|\w+))*)c                      e Zd ZU ded<   ded<   ded<   ded<   ded<   dZded	<   d
Zded<   d
Zded<   d
Zded<   d
Zded<   dZ	ded<    e
e      Zded<   y
)NodeInfor   kindname	file_pathr   
line_startline_end r   NOptional[str]parent_nameparamsreturn_type	modifiersFboolis_testdefault_factorydictextra)r   r   r   r   r   r#   r$   r%   r&   r(   r   r+   r,   r   r   r   r   r   *   sf    
I
INOMHc!%K% FM !%K%#I}#GT-E4-r   r   c                  `    e Zd ZU ded<   ded<   ded<   ded<   dZded<    ee	      Zd
ed<   y)EdgeInfor   r   r   targetr   r   r   liner)   r+   r,   N)r   r   r   r   r0   r   r+   r,   r   r   r   r.   r.   :   s0     IKKND#M-E4-r   r.   .pypython.js
javascript.jsx.ts
typescript.tsxtsxz.gogoz.rsrustz.javajavaz.cscsharpz.rbrubyz.cppcppz.ccz.cxxz.ccz.hz.hppz.ktkotlinz.swiftswiftz.phpphpz.scalascalaz.solsolidity.vuevue.dartdartz.rrz.mjsz.astroz.plperlz.pmz.tz.xsz.lualuaz.luauluauz.mobjcz.shbashelixirnotebookzig
powershellsveltejulia)z.bashz.zshz.exz.exsz.ipynbz.zigz.ps1z.psm1z.psd1z.sveltez.jldict[str, str]EXTENSION_TO_LANGUAGEclass_definitionclass_declarationclasstype_declaration)struct_item	enum_item	impl_item)rY   interface_declarationenum_declarationstruct_specifiertype_definitionclass_specifier)rY   r_   r`   struct_declarationmodule)package_statementclass_statementrole_statementobject_declaration)rY   rd   protocol_declarationr_   )rX   trait_definitionobject_definitionenum_definition)contract_declarationr_   library_declarationrd   r`   error_declarationuser_defined_type_definition)rX   mixin_declarationr`   )class_interfaceclass_implementationcategory_interfacerj   container_declarationrg   struct_definitionabstract_definition)
rE   rI   rL   rM   rN   rO   rP   rR   rS   rU   zdict[str, list[str]]_CLASS_TYPESfunction_definition)function_declarationmethod_definitionarrow_functionr{   method_declarationfunction_itemconstructor_declarationmethodsingleton_method subroutine_declaration_statementmethod_declaration_statement)rz   constructor_definitionmodifier_definitionevent_definitionfallback_receive_definitionfunction_signaturer|   fn_protofn_declfunction_statementshort_function_definition_FUNCTION_TYPESimport_statementimport_from_statementimport_declarationuse_declarationpreproc_includeusing_directivecalluse_statementrequire_expressionimport_headernamespace_use_declarationimport_directiveimport_or_exportusing_statement_IMPORT_TYPEScall_expressionnew_expressionmacro_invocationmethod_invocationobject_creation_expressioninvocation_expressionmethod_call)function_call_expressionmethod_call_expression"ambiguous_function_call_expressionr   member_call_expression)r   instance_expressiongeneric_functionfunction_callmessage_expressioncommandbuiltin_call_exprcommand_expression)	rE   rL   rM   rN   rO   rP   rR   rS   rU   _CALL_TYPESz^test_z^Testz_test$z\.test\.z\.spec\.z_spec$ztest_.*\.py$z.*_test\.py$z.*\.test\.[jt]sx?$z.*\.spec\.[jt]sx?$z.*_test\.go$ztests?/z.*_test\.dart$ztest[_-].*\.[rR]$ztests/testthat/z.*Test\.kt$z.*Test\.java$>   ittestafterAlldescribe	afterEach	beforeAll
beforeEach>   org.junit.Testorg.junit.jupiter.api.TestTestTestFactoryRepeatedTestParameterizedTestc                4     t         fdt        D              S )Nc              3  @   K   | ]  }|j                          y wNsearch).0ppaths     r   	<genexpr>z _is_test_file.<locals>.<genexpr>N  s     ;!qxx~;   )any_TEST_FILE_PATTERNSr   s   `r   _is_test_filer   M  s    ;':;;;r   c                     t         fdt        D              ryt        |      r	 t        v ry|rt        d |D              ryy)zA function is a test if its name matches test patterns, it lives
    in a test file and has a test-runner name, or it has a @Test annotation.
    c              3  @   K   | ]  }|j                          y wr   r   )r   r   r   s     r   r   z$_is_test_function.<locals>.<genexpr>W  s     
2a188D>
2r   Tc              3  ,   K   | ]  }|t         v   y wr   )_TEST_ANNOTATIONS)r   ds     r   r   z$_is_test_function.<locals>.<genexpr>[  s     EQ!00Es   F)r   _TEST_PATTERNSr   _TEST_RUNNER_NAMES)r   r   
decoratorss   `  r   _is_test_functionr   Q  s?     
2>
22YD,>$>cE*EEr   c                d    t        j                  | j                               j                         S )zSHA-256 hash of file contents.)hashlibsha256
read_bytes	hexdigestr   s    r   	file_hashr   `  s!    >>$//+,6688r   c                     e Zd ZdZdZdQdZdRdZdSdZdTdZdUdZ		 	 	 	 	 	 dUdZ
	 	 	 	 	 	 dUd	Z	 	 	 	 	 	 dUd
Z	 	 	 	 	 	 	 	 dVdZ	 	 	 	 	 	 dUdZ	 	 	 	 	 	 	 	 dWdZdZdZdXdZ	 	 	 	 	 dY	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dZdZd[dZd[dZ	 	 	 	 d\dZ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d]dZ	 	 	 	 	 	 d^dZ	 	 	 	 	 	 	 	 	 	 	 	 d_dZ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d`dZ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dadZ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d]dZ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d]dZed[d       Z e h d      Z!	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d]dZ"	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d]d Z#	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dbd!Z$	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dbd"Z%	 	 	 	 	 	 	 	 	 	 dcd#Z&	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d]d$Z'	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddd%Z(	 	 	 	 	 	 	 	 	 	 ded&Z) e d'h      Z* e d(d)h      Z+ e h d*      Z,	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dfd+Z-	 dg	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dhd,Z.	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 did-Z/	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 did.Z0	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 did/Z1	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 did0Z2	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 djd1Z3	 	 	 	 	 	 dkd2Z4	 	 	 	 dld3Z5	 	 	 	 	 	 	 	 dmd4Z6	 	 	 	 	 	 dnd5Z7	 	 	 	 	 	 	 	 dod6Z8	 	 	 	 	 	 	 	 dod7Z9	 	 	 	 	 	 dpd8Z:	 	 	 	 	 	 	 	 	 	 	 	 dqd9Z;	 	 	 	 	 	 	 	 	 	 drd:Z<	 ds	 	 	 	 	 	 	 dtd;Z=dud<Z>dvd=Z?d[d>Z@dwd?ZAdwd@ZBdxdAZCdxdBZDdwdCZEdydDZFd[dEZGedzdF       ZH e h dG      ZIdXdHZJed[dI       ZKed[dJ       ZLedK        ZMeNd{dL       ZO	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d|dMZP	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d|dNZQ	 ds	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d}dOZR	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d~dPZSy)
CodeParserzJParses source files using Tree-sitter and extracts structural information.i:  c                Z    i | _         i | _        i | _        t               | _        i | _        y r   )_parsers_module_file_cache_export_symbol_cacher
   _tsconfig_resolver_dart_pubspec_cache)selfs    r   __init__zCodeParser.__init__o  s,    +-<>>@!"2"4JL r   c                    || j                   vr#	 t        j                  |      | j                   |<   | j                   |   S # t        t        t
        f$ r!}t        j                  d||       Y d }~y d }~ww xY w)Nz)tree-sitter parser unavailable for %s: %s)r   tslp
get_parserLookupError
ValueErrorImportErrorloggerdebug)r   r   excs      r   _get_parserzCodeParser._get_parserw  si    4==(*.//(*Ch'
 }}X&&	  [9 H(TWXs   "A A6A11A6c                \    t         j                  |j                  j                               S r   )rW   getsuffixlower)r   r   s     r   detect_languagezCodeParser.detect_language  s     $(():):)<==r   c                z    	 |j                         }| j                  ||      S # t        t        f$ r g g fcY S w xY w)z9Parse a single file and return extracted nodes and edges.)r   OSErrorPermissionErrorparse_bytes)r   r   r   s      r   
parse_filezCodeParser.parse_file  sG    	__&F f-- ) 	r6M	s   $ ::c                X   | j                  |      }|sg g fS |dk(  r| j                  ||      S |dk(  r| j                  ||      S |dk(  r| j                  ||      S |dk(  r#|j	                  d      r| j                  ||      S | j                  |      }|sg g fS |j                  |      }g }g }t        |      }t        |      }	|j                  t        d||d|j                  d      dz   ||		             | j                  |j                  ||      \  }
}| j                  |j                  ||||||
|
       | j!                  |||      }|	rt#               }|D ]Q  }|j$                  s| j'                  |j(                  |j*                  |j,                        }|j/                  |       S t1        |      D ]h  }|j2                  dk(  s|j4                  |v s"|j                  t7        d|j8                  |j4                  |j*                  |j:                               j ||fS )zParse pre-read bytes and return extracted nodes and edges.

        This avoids re-reading the file from disk, eliminating TOCTOU gaps
        when the caller has already read the bytes (e.g. for hashing).
        rG   rT   rQ   r2   s   # Databricks notebook source
Filer	      
r   r   r   r   r    r   r(   
import_mapdefined_namesCALLS	TESTED_BYr   r   r/   r   r0   )r   
_parse_vue_parse_svelte_parse_notebook
startswith_parse_databricks_py_notebookr   parser   r   appendr   count_collect_file_scope	root_node_extract_from_tree_resolve_call_targetssetr(   _qualifyr   r   r#   addlistr   r   r.   r/   r0   )r   r   r   r   parsertreenodesedgesfile_path_str	test_filer   r   test_qnamesnqnedges                   r   r   zCodeParser.parse_bytes  s<    ''-r6M u??400 x%%dF33 z!''f55 xF$5$5-%
 55dFCC!!(+r6M||F# " "D	 "-0	X#\\%(1,
 	 %)$<$<NNHf%
!
M
 	NNFHmUE! 	  	
 **5%G %K (99qvvq{{AMMJBOOB'( U 99'DKK;,FLL(#{{#{{"&..!YY"  e|r   c                   | j                  d      }|sg g fS |j                  |      }t        |      }t        |      }t	        d||d|j                  d      dz   d|      g}g }|j                  j                  D ]  }	|	j                  dk7  rd}
d}d}|	j                  D ]&  }|j                  d	k(  r|}|j                  d
k(  s%|}( |r|j                  D ]  }|j                  dk(  sd}d}|j                  D ]}  }|j                  dk(  r|j                  j                  dd      }0|j                  dk(  s@|j                  D ]/  }|j                  dk(  s|j                  j                  dd      }1  |dk(  s|dv sd}
 |s|j                  }|j                  d   }| j                  |
      }|sC|j                  |      }| j                  |j                  |
|      \  }}g }g }| j                  |j                  ||
|||||       |D ]3  }|xj                  |z  c_        |xj                  |z  c_        d|_        5 |D ]  }|xj"                  |z  c_         |j%                  |       |j%                  |        |rt'               }|D ]Q  }|j(                  s| j+                  |j,                  |j.                  |j0                        }|j3                  |       S t5        |      D ]h  }|j6                  dk(  s|j8                  |v s"|j;                  t=        d|j>                  |j8                  |j.                  |j"                               j ||fS )zFParse a Vue SFC by extracting <script> blocks and delegating to JS/TS.rG   r   r	   r   r   script_elementr4   N	start_tagraw_text	attributeattribute_nameutf-8replaceerrorsquoted_attribute_valueattribute_valuelangtsr7   r7   r   r   r   r  r   r   r  r   r   r   r
  r  childrentypetextdecodestart_pointr  r  r   r    r   r0   extendr  r(   r  r   r   r#   r  r  r   r   r	  r.   r/   ) r   r   r   
vue_parserr  r  r  	all_nodes	all_edgeschildscript_langr  raw_text_nodesubattr	attr_name
attr_valueavscript_sourceline_offsetscript_parserscript_treer   r   r  r  noder  r  r  r  s                                    r   r  zCodeParser._parse_vue  s    %%e,
r6M'D	!-0	%-#\\%(1,&
 %	 %'	 ^^,, B	$Ezz-- 'KI M~~ (88{* #IXX+$'M	( %.. 7DyyK/$(	%)
!% *A vv)99,-FFMM')M,T	!"+C!C)* !*A'(vv1B'B56VV]],3I 6C 6*
!*	* %.:AU3U*6K7  !)..M'33A6K !,,[9M '--m<K )-(@(@%%{M)%J %'E$&E##%%}kue%] $   &;., %&  )		[(	) U#U#EB	$J %K (99qvvq{{AMMJBOOB'( Y 99'DKK;,F$$X(#{{#{{"&..!YY&  )##r   c                   | j                  d      }|s| j                  d      }|sg g fS |j                  |      }t        |      }t        |      }t	        d||d|j                  d      dz   d|      g}g }|j                  j                  D ]  }	|	j                  dk7  rd}
d	}d	}|	j                  D ]&  }|j                  d
k(  r|}|j                  dk(  s%|}( |r|j                  D ]  }|j                  dk(  sd	}d	}|j                  D ]}  }|j                  dk(  r|j                  j                  dd      }0|j                  dk(  s@|j                  D ]/  }|j                  dk(  s|j                  j                  dd      }1  |dk(  s|dv sd}
 |s|j                  }|j                  d   }| j                  |
      }|sC|j                  |      }| j                  |j                  |
|      \  }}g }g }| j                  |j                  ||
|||||       |D ]3  }|xj                  |z  c_        |xj                  |z  c_        d|_        5 |D ]  }|xj"                  |z  c_         |j%                  |       |j%                  |        |rt'               }|D ]Q  }|j(                  s| j+                  |j,                  |j.                  |j0                        }|j3                  |       S t5        |      D ]h  }|j6                  dk(  s|j8                  |v s"|j;                  t=        d|j>                  |j8                  |j.                  |j"                               j ||fS )a  Parse a Svelte SFC by extracting <script> blocks.

        Uses the same approach as Vue: parse the outer HTML structure,
        locate ``<script>`` blocks, detect ``lang="ts"`` for TypeScript,
        and delegate each block to the appropriate JS/TS parser.
        rT   rG   r   r	   r   r   r  r4   Nr  r   r!  r"  r#  r$  r%  r'  r(  r)  r*  r7   r   r   r   r  r  r,  ) r   r   r   svelte_parserr  r  r  r4  r5  r6  r7  r  r8  r9  r:  r;  r<  r=  r>  r?  r@  rA  rB  r   r   r  r  rC  r  r  r  r  s                                    r   r  zCodeParser._parse_svelteN  s    ((2  ,,U3Mr6M""6*D	!-0	%-#\\%(1,&
 %	 %'	 ^^,, E	$Ezz--&KI M~~ (88{* #IXX+$'M	( %.. 7DyyK/$(	%)
!% *A vv)99,-FFMM$+I -: -"	 "#+C!C)* !*A'(vv1B'B56VV]],33< 6C 6*
!** &/ *3!4 +7K+7. !)..M'33A6K ,,[9M '--m<K(,(@(@%%{M)%J %'E$&E##%%}]E5%+	 $   );., ()  )		[(	) U#U#KE	$P %K (99Q]]B  OOB'( Y II({2$$X(#{{#{{"&..!YY&  )##r   c                   	 t        j                  |      }|j	                  di       j	                  di       j	                  d      xs5 |j	                  di       j	                  di       j	                  d      xs dj                         }ddh}||vrg g fS g }dddd	}h d
}t        |j	                  dg             D ].  \  }	}
|
j	                  d      dk7  r|
j	                  dg       }t        |t              r|j                  d      }|sS|d   j                         }|}|}|j                         D ]'  \  }}||k(  s|j                  |dz         s |}|dd } n% |D ]  }||k(  s|j                  |dz         sg } n |dv r/|D cg c]#  }|j                         j                  d      s|% }}n|}|sdj                  |      }|j                  t!        |	||             1 |s)t        |      }t#        d||dd|t%        |            gg fS | j'                  |||      S # t         j                  t        f$ r g g fcY S w xY wc c}w )z2Parse a Jupyter notebook by extracting code cells.metadata
kernelspecr   language_infor   r2   rJ   sql)z%pythonz%sqlz%r>   %md%sh%scalacells	cell_typecoder   T)keependsr    r	   Nr2   rJ   )%!r!   r   r   r   r   r   )jsonloadsJSONDecodeErrorUnicodeDecodeErrorr   r   	enumerate
isinstancer   
splitlinesstripitemsr  lstripjoinr	  r   r   r   _parse_notebook_cells)r   r   r   nbkernel_lang	supportedrN  magic_lang_mapskip_magicscell_idxcelllines
first_line	cell_lang
cell_linesmagicr)  skiplnfilteredcell_sourcer  s                         r   r  zCodeParser._parse_notebook  s   	F#B FF:r"&&|R8<<ZH vvj"%))/2>BB6J
%'	 	 sO	i'r6M !#

 /'w(;< &	`NHdxx$.HHXr*E%%(($(7 q)J#IJ-335 
t&**?*?*L $I!&qrJ	
 ( D!T)Z-B-B4#:-N%'
 O+!+99;11*=  
 &''(+KLLX	R]^_M&	`P IM"'$%m4    ))${CCY $$&89 	r6M	hs   H0 (I0IIc                   t        |      }t        |      }i }|D ]-  }|j                  |j                  g       j	                  |       / g }g }	g }
d}|j                         D ]  \  }}|dk(  rl|D ]f  }t        j                  |j                        D ]B  }|j                  d      j                  dd      }|	j	                  t        d|||d             D h x|dvr}| j                  |      }|sg }g }d}|D ]  }|j                  j                  d      |j                  j                  d      sdnd	z   }|j	                  |j                  |||z   dz
  f       |j	                  |j                         ||dz   z  } dj!                  |      }|j#                  d
      }|j%                  |      }| j'                  |j(                  ||      \  }}| j+                  |j(                  |||||	||       |
j-                  |       t/        ||      } t1        d||d|||      }|j3                  d	|       | j5                  ||	|      }	|D ]F  }|j6                  dk(  r|
D ]/  \  }}}||j8                  cxk  r|k  sn  ||j:                  d<    F H |rt=               }|D ]Q  } | j>                  s| jA                  | jB                  | jD                  | jF                        }!|jI                  |!       S tK        |	      D ]h  }"|"j6                  dk(  s|"j                  |v s"|	j	                  t        d|"jL                  |"j                  |"jD                  |"jN                               j ||	fS )zParse notebook cells grouped by language.

        Args:
            path: Notebook file path.
            cells: List of CellInfo with index, language, and source.
            default_language: Default language for the File node.
        r	   rJ  `r!   IMPORTS_FROMr  rS  
r   r#  r   r   r   r   r   r  )(r   r   
setdefaultr   r	  r_  _SQL_TABLE_REfinditerr   groupr$  r.   r   r
  endswithr   ra  encoder  r  r  r  r2  maxr   insertr  r   r   r,   r  r(   r  r   r   r#   r  r  r/   r0   )#r   r   rN  default_languager  r  
lang_cellsri  r4  r5  all_cell_offsetsmax_liner)  
lang_groupmatch
table_name	ts_parsercode_chunkscell_offsetscurrent_linecell_line_countconcatenatedconcat_bytesr  r   r   	file_noderC  rh  startendr  r  r  r  s#                                      r   rb  z CodeParser._parse_notebook_cells$  s    D	!-0	 13
 	BD!!$--4;;DA	B %'	$&	
 8: * 0 0 2 6	3D*u}& 	D!.!7!7!D %*[[^%;%;C%D
!((!/#0#-&3!"* 	 ?*((.I
 &(K79LL" 4"&++"3"3D"9![[11$7AQ# ##OO\</3QTU3U%  ""4;;/! 334  99[1L'..w7L??<0D(,(@(@l)%J ##dy)%] $  ##L18\2Hm6	3r #%
	 	I& ..y-
	
  	DyyF"(8 $%DOO2s2/7DJJ|,	 %K (99qvvq{{AMMJBOOB'( Y 99'DKK;,F$$X(#{{#{{"&..!YY&  )##r   c                   |j                  dd      }|j                  d      }|r|d   j                         dk(  r|dd }g g}|D ]>  }t        j                  d	|      r|j                  g        +|d
   j                  |       @ g }ddd}d}	t        |      D ]  \  }
}|D cg c]  }|j                         s| }}|s*|d   }t        d |D              }d}|r-|j                         D ]  \  }}|j                  |      s|} n |r|D cg c]  }|j                  d      r|dd n| }}|D cg c]  }|j                         s| }}|r<|d   j                         j                  d      r|d   }|D cg c]
  }||k7  s	| }}dj                  |      }|j                  t        |
||             '|r|j                  |	      r<|D cg c]  }|j                  d      r| }}dj                  |      }|j                  t        |
d|              |s:t        |      }t        d||dddt        |            }d|j                  d<   |gg fS | j!                  ||d      \  }}|D ]%  }|j"                  dk(  sd|j                  d<    ||fS  ||fS c c}w c c}w c c}w c c}w c c}w )z'Parse a Databricks .py notebook export.r#  r$  r%  rv  r   z# Databricks notebook sourcer	   Nz^# COMMAND\s*-+\s*$rJ  rJ   )z# MAGIC %sqlz
# MAGIC %r)z# MAGIC %mdz# MAGIC %shc              3  >   K   | ]  }|j                  d         yw)# MAGIC N)r  )r   rp  s     r   r   z;CodeParser._parse_databricks_py_notebook.<locals>.<genexpr>  s     J"BMM*5Js   r     rT  rV  r2   r   r   databricks_pynotebook_format)r0  splitr^  rer  r	  r[  allr_  r  ra  r   r   r   r   r,   rb  r   )r   r   r   r/  rj  cell_chunksr0   rN  rf  skip_prefixesrh  chunkrp  	non_emptyrk  	all_magicrl  prefixr)  strippedstripped_non_emptyfirst_directiverr  py_linesr  r  r  r  rC  s                                r   r  z(CodeParser._parse_databricks_py_notebook  s+    }}WY}7 

4 U1X^^%)GG!"IE )+t 	-Dxx.5""2&B&&t,		- !#!
 7(5 -	OHe&+:rxxz:I:"1J J	JJI I$2$8$8$: LFD!,,V4$(	
  $ !mmJ7BqrFR? 
 4<%JRrxxzb%J"%J%*<Q*?*E*E*G*R*RSV*W&8&;O-5Or9NOHO"ii1X')K   Z22=A &+Lr"--
2KLHL))H-KLL#h{ W-	^ IM "'!%m4I 2AIOO-.;?"11$xHu  	DyyF"0?

,-e|	
 e|I ;&
 &K  P Ms6   'J*=J*J/9J4J4
J9J9J>3J>c           	        i }|D ]D  }|j                   dv s|j                  }| j                  |||j                        }||vs@|||<   F g }|D ]  }	|	j                   dv rld|	j                  vr^|	j                  |v rPt        |	j                   |	j                  ||	j                     |	j                  |	j                  |	j                        }	|j                  |	        |S )a  Resolve bare call targets to qualified names using same-file definitions.

        After parsing, CALLS edges store bare function names (e.g. ``FirebaseAuth``)
        as targets. This method builds a symbol table from the parsed nodes and
        qualifies any bare target that matches a local definition, so that
        ``callers_of`` / ``callees_of`` queries produce correct results.

        External calls (names not defined in this file) remain bare.
        )FunctionClassTyper   )r   
REFERENCES::)r   r   r/   r   r0   r,   )r   r   r  r#   r/   r.   r   r   r0   r,   r	  )
r   r  r  r   symbolsrC  bare	qualifiedresolvedr  s
             r   r  z CodeParser._resolve_call_targets	  s      #% 	.DyyAAyy MM$	4;K;KL	w&$-GDM	. $& 	"Dyy33DKK8O;;')#!YY#{{&t{{3"&..!YY"jjD OOD!	" r         c                   |j                   D ]  }|j                  dk(  s|j                   D ]  }|j                  dv s|j                  j                  dd      }|j	                  d      }t        j                  dd|      j	                         }t        |      | j                  kD  r|d	| j                   }|c c S   y	)
z?Extract the first string argument from a test runner call node.	arguments)stringtemplate_stringr#  r$  r%  z'"`z\s+rR  N)	r-  r.  r/  r0  r^  r  r9  len_MAX_TEST_DESCRIPTION_LEN)r   	call_noder   r6  argrawr  
normalizeds           r   _get_test_descriptionz CodeParser._get_test_description3  s    '' 		*Ezz[( >> *Cxx#@@!hhoogioH#&99V#4%'VVFC%B%H%H%J
z?T-K-KK)34Td6T6T)UJ))*		* r   Nc                   || j                   kD  ryt        t        j                  |g             }t        t        j                  |g             }t        t
        j                  |g             }t        t        j                  |g             }|j                  D ]  }|j                  }|dk(  r| j                  ||||||||||	|
      r1|dv r| j                  ||||||||||	|
|      rR|dk(  r|dk(  r| j                  |||      rp|dk(  r!|dk(  r| j                  |||||||||	|
|      r|dk(  r| j                  ||||||       |d	v r |d
v r| j                  |||||||||	|
|      r||v r| j                  ||||||||	|
|
      r|d	v r"|dk(  r| j!                  |||||||||	|
|      r||v r| j#                  ||||||||	|
|
      r:||v r| j%                  |||||       U||v r| j'                  |||||||||	|
|      rv|d	v r|dv r| j)                  |||||||	|
       | j+                  |||||||||	|

       |dk(  r| j-                  ||||||||      r| j/                  |||||||||	|
|dz           y)z1Recursively walk the AST and extract nodes/edges.NrJ   rL   rM   rO   r   rP   r   rI   r4   r7   r9   lexical_declarationvariable_declarationpublic_field_definition)jsx_opening_elementjsx_self_closing_elementrE   r	   enclosing_classenclosing_funcr   r   _depth)_MAX_AST_DEPTHr  ry   r   r   r   r   r-  r.  _extract_r_constructs_extract_lua_constructs_extract_bash_source_command_extract_elixir_constructs!_extract_dart_calls_from_children_extract_js_var_functions_extract_classes_extract_js_field_function_extract_functions_extract_imports_extract_calls_extract_jsx_component_call_extract_value_references_extract_solidity_constructsr  )r   rootr   r   r   r  r  r  r  r   r   r  class_types
func_typesimport_types
call_typesr6  	node_types                     r   r  zCodeParser._extract_from_treeA  s    D''',**8R89,,Xr:;
=,,Xr:;267
]] P	E

I 34#=#=y&(Iuo~M$
  ?*t/K/Ky&(Iuo~M60
  6!i9&<449e  8#	V(;2268Yu#^v
  6!6669e#^ ??!PP2268Yu#^v  K'D,A,AvxE5]-
  ??!::3368Yu#^v  J&4+B+BvxE5],
  L(%%8VY  J&&&68Yu#^v
  ??!TT008Y#^ **y&(IuM :%$*K*Ky&)UE+  ##vxE5 /-%]z $ UP	r   c                B   |j                   sy|j                   d   }|j                  dk(  r|j                  j                  dd      S |j                  dk(  rHt	        |j                         D ]0  }|j                  dk(  s|j                  j                  dd      c S  y)a8  Return the leading identifier of an Elixir ``call`` node.

        For ``def add(a, b)`` returns ``"def"``; for ``defmodule Calc``
        returns ``"defmodule"``; for ``IO.puts(msg)`` returns the dotted
        path's final identifier (``"puts"``); for ``alias Calculator``
        returns ``"alias"``.
        Nr   
identifierr#  r$  r%  dot)r-  r.  r/  r0  reversed)r   rC  firstr6  s       r   _elixir_call_identifierz"CodeParser._elixir_call_identifier  s     }}a ::%::$$WY$??::!%..1 H::- ::,,WY,GGH r   c                    |j                   D ]^  }|j                  dk(  r|j                  j                  dd      c S |j                  dk(  sA|j                  j                  dd      c S  y)zExtract a module name from a ``defmodule`` / ``alias`` / etc.
        arguments node. Supports ``Calc`` (single alias) and ``Foo.Bar``
        (dotted alias inside a `dot` node).
        aliasr#  r$  r%  r  Nr-  r.  r/  r0  )r   r  r6  s      r   _elixir_module_namezCodeParser._elixir_module_name  sl    
 '' 	DEzzW$zz(((CCzzU"zz(((CC		D
 r   c                   |j                   D ]  }|j                  dk(  rd}|j                   D ]2  }|j                  dk(  s||j                  j                  dd      }4 |j                  j                  dd      }|r|j	                  |      r|t        |      d }||fc S |j                  dk(  s|j                  j                  dd      dfc S  y)a/  Extract the function name and parameter list from a ``def``/
        ``defp``/``defmacro`` arguments node.

        The ``arguments`` of a ``def`` call wraps another ``call`` whose
        first child is the function's identifier and whose children
        (past the parens) are the parameters.
        r   Nr  r#  r$  r%  )NN)r-  r.  r/  r0  r  r  )r   r  r   r6  r   r9  params_texts          r    _elixir_function_name_and_paramsz+CodeParser._elixir_function_name_and_params	  s     '' 	JEzzV#&* >> JCxx</DL"xxwyIJ
 $jj//	/JK2248"-c$ij"9K[((zz\) zz(((CTII!	J" r   c                   | j                  |      }|y|dk(  rd}d}|j                  D ]&  }|j                  dk(  r|}|j                  dk(  s%|}( |y| j                  |      }|y| j	                  ||d      }|j                  t        d|||j                  d   dz   |j                  d   dz   |d	             |j                  t        d
||||j                  d   dz                || j                  |||||||d|	|
|dz          y|dv r$d}d}|j                  D ]&  }|j                  dk(  r|}|j                  dk(  s%|}( |y| j                  ||      \  }}|yt        ||      }|rdnd}| j	                  |||      }|j                  t        ||||j                  d   dz   |j                  d   dz   ||||	             |r| j	                  ||d      n|}|j                  t        d
||||j                  d   dz                || j                  |||||||||	|
|dz          y|dv re|j                  D ]U  }|j                  dk(  s| j                  |      }|/|j                  t        d||||j                  d   dz                 y y|ri|}| j	                  |||      }| j                  ||||	xs i |
xs
 t                     }|j                  t        d||||j                  d   dz                |j                  D ]0  }|j                  dv s| j                  |||||||||	|
|dz          2 y)u>  Handle every Elixir ``call`` node by dispatching on the leading
        identifier. See: #112

        Returns True if the node was fully handled (and the main loop
        should skip generic recursion); False to let the default dispatch
        continue (never used here — Elixir has no other node types).
        NF	defmoduler  do_blockr  r   r	   r   r   r   r   r    r   r#   CONTAINSr  r  T)defdefpdefmacro	defmacropr   r  	r   r   r   r   r    r   r#   r$   r(   )r  importrequireuseru  r   )r  r  )r  r-  r.  r  r  r	  r   r1  	end_pointr.   r  r  r   _resolve_call_targetr  )r   rC  r   r   r   r  r  r  r  r   r   r  identr  r  r9  mod_namer  fn_namer$   r(   r   	containermod	call_namecallerr/   s                              r   r  z%CodeParser._extract_elixir_constructs&  s'   * ,,T2= KIH}} #88{* #IXX+"H	#
  //	:Hh	4@ILL#++A.2*Q.!   LL  #%%a(1,  #''fh	5%$,#')!A: (   <<IH}} #88{* #IXX+"H	#
  "CC6OGV ';G$6*Dgy/JILL#++A.2*Q.!+
 
 # oy$?(1  LL  #%%a(1,  #''fh	5%$3#*)!A: (   99}} 88{*2237CX!/#,#&&/!%!1!1!!4q!8&   
  I]]	?F ..9h b-"835F LL#%%a(1,  == 	Cxx44''9eU$3#1)!A: ( 	 r   c           
     4   d}g }|j                   D ]  }|j                  dk(  r,|j                  j                  dd      j	                         }>|j                  dv sM|sP|j                  j                  dd      j	                         }t        |      dk\  r|d   d	v r|d
   |d   k(  r|dd
 }|s|j                  |        |dv rN|rL|d   }| j                  ||d      }	|j                  t        d||	r|	n|||j                  d   dz                yy)zDetect ``source foo.sh`` / ``. foo.sh`` and emit an IMPORTS_FROM
        edge. Returns True if handled (so the main loop skips recursing
        into this command). See: #197
        Ncommand_namer#  r$  r%  )wordr  
raw_string   r   )'"r  r	   )r   .rO   ru  r  TF)
r-  r.  r/  r0  r^  r  r	  _resolve_module_to_filer.   r1  )
r   rC  r   r  r  argsr9  txtr/   r  s
             r   r  z'CodeParser._extract_bash_source_command  s     '+== 		%Cxx>)"xxwyIOOQ==,hhoogio@FFHs8q=SVz%9c"gQ>Oa)CKK$		% ?*t!WF33FIvNHLL# #+x#%%a(1,  r   c                Z   d}|j                   D ]  }|j                  dk(  r|j                  j                  dd      }1|j                  dk(  rd}	d}
|j                   D ]c  }|j                  dk(  r@|j                   D ]0  }|j                  dk(  s|j                  j                  dd      }	 P R|j                  d	k(  sbd
}
e |	|	}|
rJ|rH|r| j	                  |||      n|}|j                  t        d||||j                  d   dz                d}|j                  dvsd} y)a  Detect Dart call sites from a parent node's children (#87 bug 1).

        tree-sitter-dart does not emit a single ``call_expression`` node for
        Dart calls.  Instead it produces ``identifier`` / method-selector
        siblings followed by a ``selector`` whose child is ``argument_part``:

            identifier "print"
            selector
              argument_part

        And for method calls like ``obj.foo()`` the middle selector is a
        ``unconditional_assignable_selector`` holding the method name:

            identifier "obj"
            selector
              unconditional_assignable_selector "."
                identifier "foo"
            selector
              argument_part

        This walker scans the immediate children of ``parent`` for either
        shape and emits a ``CALLS`` edge.  Nested calls are picked up as
        ``_extract_from_tree`` recurses into child nodes.
        Nr  r#  r$  r%  selectorF!unconditional_assignable_selectorargument_partTr   r   r	   r  )returnawaityieldthisconstnew)r-  r.  r/  r0  r  r	  r.   r1  )r   parentr   r   r  r  r  r  r9  method_namehas_argumentsssubr  src_qns                 r   r  z,CodeParser._extract_dart_calls_from_children  sT   B $(	?? *	!Cxx<'HHOOGIOF	xx:% .2 %LL 	-Dyy$GG%)]] &E$zz\9.3jj.?.?$+I /@ /" !&& o5(,	- * +I Y * niQ/8  LL$%("+#//2Q6"  !%I
 xxSS 	U*	!r   c                    |dk(  r| j                  ||||||||	|
|
      }|ry|dk(  r| j                  ||||||||	|
|
      }|ryy)zHandle R-specific AST nodes (assignments and class-defining calls).

        Returns True if the child was fully handled and should be skipped
        by the main loop.
        binary_operatorTr   F)_handle_r_binary_operator_handle_r_call)r   r6  r  r   r   r   r  r  r  r  r   r   handleds                r   r  z CodeParser._extract_r_constructs?  sx    ( ))44vxE5MG
  ))vxE5MG
 r   c                F   |dk(  r| j                  ||||||||	|
||      S |dk(  r| j                  ||||||||	|
||      S |dk(  r\|	sZ| j                  |      }|G| j                  |||      }|j	                  t        d||r|n|||j                  d   dz                yy	)
a  Handle Lua-specific AST constructs.

        Returns True if the child was fully handled and should be skipped
        by the main loop.

        Handles:
        - variable_declaration with require() -> IMPORTS_FROM edge
        - variable_declaration with function_definition -> named Function node
        - function_declaration with dot/method name -> Function with table parent
        - top-level require() call -> IMPORTS_FROM edge
        r  r{   r   ru  r   r	   r  TF) _handle_lua_variable_declaration_handle_lua_table_function_lua_get_require_targetr  r	  r.   r1  )r   r6  r  r   r   r   r  r  r  r  r   r   r  
req_targetr  s                  r   r  z"CodeParser._extract_lua_constructsl  s    6 ..88vxE5M6  ..22vxE5M6  '55e<J%77	8 X'$'/8Z'**1-1  r   c                n   d}|j                   D ]  }|j                  dk(  s|} n |syd}|j                   D ]R  }|j                  dk(  s|j                   D ]0  }|j                  dk(  s|j                  j                  dd      } n  n d}|j                   D ]  }|j                  d	k(  s|} n |r|sy|j                   D ]m  }|j                  d
k(  s| j	                  |      }|'| j                  |||      }|j                  t        d||r|n|||j                  d   dz                 y |j                   D ]  }|j                  dk(  st        ||      }|rdnd}| j                  |||      }| j                  |||      }|j                  t        ||||j                  d   dz   |j                  d   dz   ||||	             |r| j                  ||d      n|}|j                  t        d||||j                  d   dz                | j                  |||||||||	|
|dz           y y)zHandle Lua variable declarations that contain require() or
        anonymous function definitions.

        ``local json = require("json")``  -> IMPORTS_FROM edge
        ``local fn = function(x) ... end`` -> Function node named "fn"
        Nassignment_statementFvariable_listr  r#  r$  r%  expression_listr   ru  r   r	   r  Trz   r   r  r  r  r  )r-  r.  r/  r0  r"  r  r	  r.   r1  r   r  _get_paramsr   r  r  )r   r6  r   r   r   r  r  r  r  r   r   r  assignr9  var_namer  	expr_listexprr#  r  r(   r   r  r$   r  s                            r   r   z+CodeParser._handle_lua_variable_declaration  s   * >> 	Cxx11	  ?? 	Cxx?* \\ Ezz\1#(::#4#4WY#4#O 	 	?? 	Cxx,,		
 y && 	 DyyO+!99$?
)#;;"Ix H LL+(+3x"+"..q1A5"   	 " && &	Dyy11+Hi@!(vj MM(IO	))$&AX!'$003a7"__Q/!3% /!#
 
 ' MM/9dC,5  X#$$'**1-1  ''&(Iue$3#+)"/!A: (  M&	P r   c                   d}d}|j                   D ]  }|j                  dv s|j                   D cg c]  }|j                  dk(  s| }}t        |      dk\  r@|d   j                  j	                  dd      }|d	   j                  j	                  dd      } n |r|sy
t        ||      }|rdnd}| j                  |||      }| j                  |||      }|j                  t        ||||j                  d   dz   |j                  d   dz   ||||	             | j                  ||d      }|j                  t        d||||j                  d   dz                | j                  |||||||||	|
|dz          yc c}w )a#  Handle Lua function declarations with table-qualified names.

        ``function Animal.new(name)``  -> Function "new", parent "Animal"
        ``function Animal:speak()``    -> Function "speak", parent "Animal"

        Plain ``function foo()`` is NOT handled here (returns False).
        Ndot_index_expressionmethod_index_expressionr  r  r   r#  r$  r%  r  Fr   r  r	   r  r  r  r  T)r-  r.  r  r/  r0  r   r  r(  r	  r   r1  r  r.   r  )r   r6  r   r   r   r  r  r  r  r   r   r  r  r  r9  r@   identifiersr(   r   r  r$   r  s                         r   r!  z%CodeParser._handle_lua_table_function  s   * 
>> 	CxxNN"||qvv/EA  {#q(!,Q!4!4!;!;	 "< "J #.b/"6"6"="=	 #> #K 	 #K; vjMM+y*E	!!%6:X((+a/__Q'!+"

 
	 MM*i>	X""1%)
 	 	68Yu&&!'A: 	  	
 cs   E?E?c                   | j                   r| j                   d   nd}|r|j                  dk7  s|j                  dk7  ry| j                   D ]  }|j                  dk(  s|j                   D ]  }|j                  dk(  s|j                   D ]4  }|j                  dk(  s|j                  j                  dd	
      c c c S  |j                  j                  dd	
      }|j	                  d      c c S   y)zExtract the module path from a Lua require() call.

        Returns the string argument or None if this is not a require() call.
        r   Nr  s   requirer  r  string_contentr#  r$  r%  '")r-  r.  r/  r0  r^  )r  first_childr6  r  r9  r  s         r   r"  z"CodeParser._lua_get_require_targetb  s     09/A/Ai((+t</:-'' 	0Ezz[( >> 
0Cxx8+#&<< "C"xx+;;'*xx$+I (7 (" !"" "hhoogioH"yy//
0	0 r   >   functionr}   function_expressionc                   d}|j                   D ]m  }|j                  dk7  rd}d}|j                   D ]L  }|j                  dk(  r ||j                  j                  dd      }2|j                  | j                  v sK|}N |r|sxt        ||      }|rdnd	}| j                  |||      }| j                  |||      }| j                  |||      }|j                  t        ||||j                  d
   dz   |j                  d
   dz   |||||
             |r| j                  ||d      n|}|j                  t        d||||j                  d
   dz                | j                  |||||||||	|
|dz          d}p |syy)ad  Handle JS/TS variable declarations that assign functions.

        Patterns handled:
          const foo = () => {}
          let bar = function() {}
          export const baz = (x: number): string => x.toString()

        Returns True if at least one function was extracted from the
        declaration, so the caller can skip generic recursion.
        Fvariable_declaratorNr  r#  r$  r%  r   r  r   r	   
r   r   r   r   r    r   r#   r$   r%   r(   r  r  r  T)r-  r.  r/  r0  _JS_FUNC_VALUE_TYPESr   r  r(  _get_return_typer	  r   r1  r  r.   r  )r   r6  r   r   r   r  r  r  r  r   r   r  r  
declaratorr*  	func_noder9  r(   r   r  r$   ret_typer  s                          r   r  z$CodeParser._extract_js_var_functions  s   0 .. 7	J"77 HI!** $88|+0@"xxwyIHXX!:!:: #I	$ 9')<G$6*Dh	?KI%%i6BF,,Y&IHLL# ,,Q/!3+a/!+$  # oy$?(1  LL  #&&q)A-  ##68Yu /'%+z $  Go7	r r   c                   d}d}|j                   D ]L  }|j                  dk(  r ||j                  j                  dd      }2|j                  | j                  v sK|}N |r|syt        ||      }|rdnd}| j                  |||      }| j                  |||      }|j                  t        ||||j                  d	   d
z   |j                  d	   d
z   ||||	             |r| j                  ||d      n|}|j                  t        d||||j                  d	   d
z                | j                  |||||||||	|
|d
z          y)z<Handle class field arrow functions: handler = (e) => { ... }Nproperty_identifierr#  r$  r%  Fr   r  r   r	   r  r  r  r  T)r-  r.  r/  r0  r;  r   r  r(  r	  r   r1  r  r.   r  )r   r6  r   r   r   r  r  r  r  r   r   r  	prop_namer>  r9  r(   r   r  r$   r  s                       r   r  z%CodeParser._extract_js_field_function  s~    		>> 	 Cxx00Y5FHHOOGIOF	T666			  	#Iy9 vjMM)YH	!!)Xv>X((+a/__Q'!+'

 
	  MM/9d;$- 	 	X""1%)
 	 	vxE5+$!'A: 	  	
 r   c                   | j                  ||d      }|syi }|dk(  ra|j                  dk(  r>h d}|j                  D ]*  }|j                  j	                  dd      }||v s%||d	<    n n|j                  d
k(  rd|d	<   t        d|||j                  d   dz   |j                  d   dz   |||      }|j                  |       |j                  t        d|| j                  |||      ||j                  d   dz                | j                  |||      }|D ]B  }|j                  t        d| j                  |||      |||j                  d   dz                D | j                  |||||||d||	|
dz          y)zExtract a class definition node and its inheritance edges.

        Returns True if the child was handled (class with a name found).
        rZ   FrB   rY   >   enumactorrZ   struct	extensionr#  r$  r%  
swift_kindrj   protocolr  r   r	   )r   r   r   r   r    r   r#   r,   r  r  INHERITSNr  T)	_get_namer.  r-  r/  r0  r   r1  r  r	  r.   r  
_get_basesr  )r   r6  r   r   r   r  r  r  r   r   r  r   r,   _swift_keywordskw_childkw_textrC  basesbases                      r   r  zCodeParser._extract_classes  s   " ~~eXw7 wzz00"S % H&mm22792MG/1.5l+	
 55&0l#((+a/__Q'!+'	
 	T 	X==y/B""1%)
 	 x8 		DLL}})_ #&&q)A- 		 	68Yu !A:	 	  	
 r   c                   | j                  ||d      }|sy|dk(  r$|j                  dk(  r| j                  |      }|r|}d}g }|j                  D ]}  }|j                  dk(  s|j                  D ]\  }|j                  dv s|j                  j                  dd	
      }|j                  |j                  d      j                                ^  |j                  r|j                  j                  dk(  rv|j                  j                  D ]]  }|j                  dk(  s|j                  j                  dd	
      }|j                  |j                  d      j                                _ |rt        |      }t        |||      }|rdnd}| j                  |||      }| j                  |||      }| j                  |||      }t        ||||j                   d   dz   |j"                  d   dz   |||||
      }|j                  |       |r| j                  ||d      n|}|j                  t%        d||||j                   d   dz                |dk(  r|j                  D ]~  }|j                  dk(  s|j                  D ]]  }|j                  dk(  s|j                  t%        d||j                  j                  dd	
      ||j                   d   dz                 ~  | j'                  ||||||||||	|
dz          y)zExtract a function/method definition node.

        Returns True if the child was handled (function with a name found).
        r6  Fr:   r~   r   r&   )
annotationmarker_annotationr#  r$  r%  @decorated_definition	decoratorr   r  r   r	   r:  Nr  r  rE   modifier_invocationr  r   r  T)rK  r.  _get_go_receiver_typer-  r/  r0  r	  r`  r^  r  tupler   r  r(  r<  r   r1  r  r.   r  )r   r6  r   r   r   r  r  r  r   r   r  r   receiver_typer   	deco_listr9  r  r/  sibr(   r   r  r$   r?  rC  r  r  s                              r   r  zCodeParser._extract_functionsn  s   " ~~eXz:
 t

.B B 66u=M"/ ')
!	>> 	CCxx;&<< CCxx#FF"xxwyI!((S)9)?)?)ABC	C <<ELL--1GG||,, ?88{*88??79?ED$$T[[%5%;%;%=>? y)J#D)Z@ vjMM$	?C	!!%6:((&A((+a/__Q'!+' 
 	T
  MM/9d; 	
 	X""1%)
 	 z!~~ "8844!$ " ::5!LL%,'0',zz'8'8$+I (9 (" +4%(__Q%7!%;*  """  	68Yu+D!A:	 	  	
 r   c                    | j                  |||      }|D ]H  }| j                  |||      }|j                  t        d||r|n|||j                  d   dz                J y)z3Extract import edges from an import statement node.ru  r   r	   r  N)_extract_importr  r	  r.   r1  )	r   r6  r   r   r   r  imports
imp_targetr  s	            r   r  zCodeParser._extract_imports  sv     &&uh?! 
	J33IxH LL# #+x#&&q)A- 	
	r   c                z   | j                  |||      }|}|r-|dv r)t        |      r|t        vr| j                  ||      xs |}|r	|dv rt        |      r|t        v r| j	                  ||      }|j
                  d   dz   }|r| d| n|}| d| }| j                  |||      }|j                  t        d|||j
                  d   dz   |j                  d   dz   ||d             |r| j                  |||      n|}|j                  t        d	||||j
                  d   dz   
             | j                  |||||||||	|
|dz          y|ri|rg| j                  |||      }| j                  ||||	xs i |
xs
 t                     }|j                  t        d||||j
                  d   dz   
             y)a  Extract call expressions, including test runner special cases.

        Returns True if the child was fully handled (test runner call that
        should skip default recursion). Returns False if the caller should
        continue to Solidity handling and default recursion.
        r  r   r	   :z@Lr   T)r   r   r   r   r    r   r#   r(   r  r  r  r   F)_get_call_namer   r   _get_base_call_namer  r1  r  r	  r   r  r.   r  r  r  )r   r6  r   r   r   r  r  r  r  r   r   r  r  effective_call_name	test_descline_nosynthetic_basesynthetic_namer  r  r  r/   s                         r   r  zCodeParser._extract_calls  s>   ( ''x@	
 (??i(!33 ((7D9    ??i(#'99225&AI''*Q.G  ''q4"5  !//r';N	?I LL## ,,Q/!3+a/!+	 	  " "I   LL  #&&q)A-  ##vxE5 /-%]z $  ]]	?F ..9h b-"835F LL#&&q)A-  r   c	           
         |sy| j                  ||||xs i |xs
 t                     }	|	sy| j                  |||      }
|j                  t	        d|
|	||j
                  d   dz                y)aX  Emit a synthetic CALLS edge for JSX component usage.

        React-style component invocations use JSX rather than ``call_expression``.
        Treat uppercase component tags such as ``<MarkdownMsg />`` as call-like
        edges so caller/impact queries can cross the JSX boundary. Intrinsic DOM
        tags (``<div>``) are ignored.
        Nr   r   r	   r  )_resolve_jsx_component_targetr  r  r	  r.   r1  )r   r6  r   r   r  r  r  r   r   r/   r  s              r   r  z&CodeParser._extract_jsx_component_call]	  s}    $ 338Y
(8b-:P35
 ~y/JX""1%)
 	r   c                    | j                  |      }|y|\  }}|| j                  |||||      S ||v r| j                  |||   ||      }	|	r|	S |S )z1Resolve a JSX component element to a call target.N)_get_jsx_component_referencer  _resolve_imported_symbol)
r   rC  r   r   r   r   component_ref	base_namecomponent_namer  s
             r   rl  z(CodeParser._resolve_jsx_component_target	  s     99$? $1!	>,,	8Z  
"44
9 5y(H r   pairarrayr  >   clsNoneTruenullr   r  trueFalsefalsesuper	undefinedc                   |	xs i }|
xs
 t               }|r| j                  |||      }n|}|| j                  v r| j                  ||||||||       y|dk(  rK|dv rG|j                  j                  dd      }| j                  ||||||||j                  d   dz   	       y|d
v r| j                  ||||||||       y|| j                  v r| j                  ||||||||       y|dk(  r| j                  ||||||||       yy)u&  Emit ``REFERENCES`` edges for function-as-value patterns.

        Detects identifiers in value positions that likely refer to
        functions — object literal values, map property assignments,
        array elements, and callback arguments.  This reduces false
        positives in dead-code detection for dispatch-map patterns
        like ``Record<string, Handler>``.

        Only emits edges when the identifier matches a locally defined
        name or an imported symbol, avoiding noise from arbitrary
        variable references.
        Nshorthand_property_identifierr  r#  r$  r%  r   r	   r0   )assignment_expressionaugmented_assignment
assignmentr  )r  r  _PAIR_TYPES_ref_from_pairr/  r0  _emit_reference_if_knownr1  _ref_from_assignment_ARRAY_TYPES_ref_from_array_ref_from_arguments)r   r6  r  r   r   r   r  r  r  r   r   imapdnamesr  r   s                  r   r  z$CodeParser._extract_value_references	  s\   2 R'#% ]]>9oNFF (((vxFESWY_` 88??::$$WY$?D))h	65$&&q)A- *   WW%%vxFE4  )))  )VUTXZ`a #$$vxFE4 $r   c	           	         |r|| j                   v ry|j                         st        |      dk  ry||vr||vry| j                  |||||      }	|j	                  t        d||	||             y)z@Emit a ``REFERENCES`` edge if *name* is a known function/import.Nr	   r  r  )_VALUE_REF_SKIP_NAMESisupperr  r  r	  r.   )
r   r   r   r   r  r  r   r   r0   r/   s
             r   r  z#CodeParser._emit_reference_if_known	  s~     tt999<<>SY!^}$Z)?**)Xz=
 	X
 	r   c	                   |j                   }	d}
t        |	      D ]  }|j                  dvs|}
 n |
y|
j                  dk(  rG|
j                  j	                  dd      }| j                  ||||||||
j                  d   dz   	       yy)
zAExtract a REFERENCES edge from an object/dict literal pair value.N)rc  ,commentr  r#  r$  r%  r   r	   r  )r-  r  r.  r/  r0  r  r1  )r   	pair_noder   r   r   r  r  r   r   r-  
value_nodechr   s                r   r  zCodeParser._ref_from_pair
  s     %%
8$ 	Bww33
	 ??l*??))'))DD))h	65M++A.2 *  +r   c	                Z   |j                   }	t        |	      dk  ry|	d   }
|
j                  dvryd}t        |	      D ]  }|j                  dvs|} n ||j                  dk7  ry|j                  j                  dd	      }| j                  ||||||||j                  d   d
z          y)zFExtract REFERENCES from ``obj.key = fnRef`` or ``obj['key'] = fnRef``.   Nr   )member_expressionsubscript_expressionr!  	subscript)=rc  r  r  type_annotationr  r#  r$  r%  r	   r  )r-  r  r.  r  r/  r0  r  r1  )r   assign_noder   r   r   r  r  r   r   r-  lhsrhsr  r   s                 r   r  zCodeParser._ref_from_assignment2
  s     ''x=1qk88 
 
 8$ 	BwwKK	 ;#((l2xxwy9%%(Ivu#a' 	& 	
r   c	                    |j                   D ]X  }	|	j                  dk(  s|	j                  j                  dd      }
| j	                  |
|||||||	j
                  d   dz          Z y)	zAExtract REFERENCES from array/list elements that are identifiers.r  r#  r$  r%  r   r	   r  Nr-  r.  r/  r0  r  r1  )r   
array_noder   r   r   r  r  r   r   r  r   s              r   r  zCodeParser._ref_from_arrayW
  so     %% 	Bww,&ww~~gi~@--(Ivu*Q. . 	r   c	                    |j                   D ]X  }	|	j                  dk(  s|	j                  j                  dd      }
| j	                  |
|||||||	j
                  d   dz          Z y)	z9Extract REFERENCES from identifier arguments (callbacks).r  r#  r$  r%  r   r	   r  Nr  )r   	args_noder   r   r   r  r  r   r   r  r   s              r   r  zCodeParser._ref_from_argumentsl
  so     $$ 	Bww,&ww~~gi~@--(Ivu*Q. . 	r   c	                   |dk(  r|r|j                   D ]  }	|	j                  dk(  s|	j                   D ]o  }
|
j                  dk(  s| j                  |||      }|j                  t	        d||
j
                  j                  dd      ||j                  d   d	z   
             q  y|dk(  r\|rYd}d}d}d}|j                   D ]  }	|	j                  dk(  r|	j
                  j                  dd      }0|	j                  dk(  r|	j
                  j                  dd      }]|	j                  dk(  r|	j
                  j                  dd      }|	j                  dv s|	j                  } |r| j                  |||      }|j                  t        d|||j                  d   d	z   |j                  d   d	z   d|||d|d
             |j                  t	        d| j                  ||d      |||j                  d   d	z   
             yy|dk(  rd}d}|j                   D ]\  }	|	j                  dk(  r|	j
                  j                  dd      }0|	j                  dk(  s@|	j
                  j                  dd      }^ |r| j                  |||      }|j                  t        d|||j                  d   d	z   |j                  d   d	z   d||ddi	             |r| j                  ||d      n|}|j                  t	        d||||j                  d   d	z   
             yy|dk(  rd}|j                   D ]P  }	|	j                  dk(  s|	j                   D ]/  }
|
j                  dk(  s|
j
                  j                  dd      }1 R |rF|r| j                  ||d      n|}|j                  t	        d||||j                  d   d	z   
             yy)zHandle Solidity-specific AST constructs (emit, state vars, etc.).

        Returns True if the child was fully handled and should skip
        default recursion.
        emit_statement
expressionr  r   r#  r$  r%  r   r	   r  Fstate_variable_declarationN
visibility	type_name)constant	immutabler  rE   state_variable)solidity_kind
mutability)
r   r   r   r   r    r   r#   r%   r&   r,   r  Tconstant_variable_declarationr  r  )	r   r   r   r   r    r   r#   r%   r,   r   
type_alias
DEPENDS_ON)
r-  r.  r  r	  r.   r/  r0  r1  r   r  )r   r6  r  r   r   r  r  r  r  r9  r  r  r*  var_visibilityvar_mutabilityvar_typer  r  lib_namesource_names                       r   r  z'CodeParser._extract_solidity_constructs
  sS   " ((^~~ 88|+!$  ::5%)]] .	 /&F "LL%,'-',zz'8'8$+I (9 (" +4%*%6%6q%9A%=* $  44H!N!NH~~ .88|+"xx	  /  H XX-%(XX__	 &5 &N XX,"xx	  /  H XX!::%(XXN.  MMi	 X#!'$003a7"__Q/!3' / (,)9&4  X#=='D %'**1-1   77HH~~ 88|+"xx	  /  H XX,"xx	  /  H  MMi	 X#!'$003a7"__Q/!3' / (*J7
 
 ' MM/9dC" 
 X#$$'**1-1   ))H~~ 88|+!$  ::5',zz'8'8 '	 (9 (H 
 ' MM'D #  X%&#'**1-1  r   c                   i }t               }t        t        j                  |g             }t        t        j                  |g             }t        t        j                  |g             }ddh}	|j
                  D ]s  }
|
j                  }|
}||	v r2|
j
                  D ]"  }|j                  |v s|j                  |v s |} n< n:|dv r6|dk(  r1|
j
                  D ]"  }|j                  |v s|j                  |v s |} n |j                  }|dk(  rv|dk(  rq|j
                  }t        |      dk\  rW|d   j                  d	k(  rE|d
   j                  dk(  r3|d   j                  j                  dd      }|j                  |       	||v s||v r.| j                  ||||v rdnd      }|r|j                  |       ?|dv r|dk(  r| j                  |
|       ||v s`| j                  |
|||       v ||fS )a-  Pre-scan top-level AST to collect import mappings and defined names.

        Returns:
            (import_map, defined_names) where import_map maps imported names
            to their source module/path, and defined_names is the set of
            function/class names defined at file scope.
        rV  rW  r  export_statementrJ   r  r  r   r  r  rz   r#  r$  r%  rZ   r6  )r  ry   r   r   r   r-  r.  r  r/  r0  r  rK   _collect_js_exported_local_names_collect_import_names)r   r  r   r   r   r   r  r  r  decorator_wrappersr6  r  r/   innertarget_type
r_childrenr   s                    r   r  zCodeParser._collect_file_scope$  s$    &(
"%%,**8R89,,Xr:;
=,,Xr:; 5kB]] 1	PE

I F.."^^ EzzZ/5::3L!&
 ??!33"^^ EzzZ/5::3L!&
 !++K 3;2C#C#__

Oq("1**l:"1**.CC%a=--44WY4OD!%%d+ j(K;,F~~fh1<1KgQ[]!%%d+ ??!3355e]K L(**5(FJOc1	Pf =((r   c           	     "   |j                   D ]  }|j                  dv s|j                   D ]`  }|j                  dk(  s|j                   D ]?  }|j                  dk(  s|j                  |j                  j	                  dd              ` b  y)z<Collect locally exported JS/TS names from export statements.r  r9  r  r#  r$  r%  N)r-  r.  r  r/  r0  )r   rC  r   r6  r9  parts         r   r  z+CodeParser._collect_js_exported_local_namesm  s     ]] 		&EzzLL >> &Cxx#88$'LL &D#yyL8 - 1 1$(II$4$4WY$4$O!" !&&&		&r   c                $   |dk(  r|j                   dk(  rd}d}|j                  D ]  }|j                   dk(  r |s|j                  j                  dd      }2|j                   d	k(  rd
}D|sG|sJ|j                   dv r#|j                  j                  dd      }|||<   {|j                   dk(  s|j                  D 	cg c]-  }	|	j                   dv r|	j                  j                  dd      / }
}	|
s|||
d   <    yy|dv rd}|j                  D ]>  }|j                   dk(  s|j                  j                  dd      j	                  d      }@ |r5|j                  D ]%  }|j                   dk(  s| j                  |||       ' yyyc c}	w )z@Extract imported names and their source modules into import_map.r2   r   NFdotted_namer#  r$  r%  r  T)r  r  aliased_importr  r  r  r4  import_clause)r.  r-  r/  r0  r^  _collect_js_import_names)r   rC  r   r   r   re   seen_import_keywordr6  r   r9  namess              r   r  z CodeParser._collect_import_names|  s    xyy33&+#!]] ?Ezz]2;N!&!2!279!2!Mx/.2+, ::)FF#(::#4#4WY#4#OD/5Jt,"ZZ+;; ,1>>%$'#&88/L#L !$	 J%E %  %8>
59 5%?	 40 <<F W::)"ZZ..wy.IOOPUVFW !]] QEzz_455eVZPQ  =%s   >2Fc           	     4   |j                   D ]  }|j                  dk(  r!|||j                  j                  dd      <   4|j                  dk(  rC|j                   D ]3  }|j                  dk(  s|||j                  j                  dd      <     |j                  dk(  s|j                   D ]_  }|j                  dk(  s|j                   D cg c]-  }|j                  dv r|j                  j                  dd      / }}|sX|||d	   <   a  y
c c}w )z>Walk JS/TS import_clause to extract named and default imports.r  r#  r$  r%  namespace_importnamed_importsimport_specifierr  rA  r  Nr  )	r   clause_nodere   r   r6  r9  specsr  s	            r   r  z#CodeParser._collect_js_import_names  s    !)) 	;Ezz\)KQ
5::,,WY,GH11 >> Cxx</QW
388??79?#MN .!NN 
;Dyy$66 &*]]! ! vv)NN FFMM')MD! ! !4:JuRy1
;	;!s   2Dc                L   t        t        |      j                        }| d| d| }|| j                  v r| j                  |   S | j	                  |||      }t        | j                        | j                  k\  r| j                  j                          || j                  |<   |S )zResolve a module/import path to an absolute file path.

        Uses self._module_file_cache to avoid repeated filesystem lookups.
        rc  )r   r   r  r   _do_resolve_moduler  _MODULE_CACHE_MAXclear)r   re   r   r   
caller_dir	cache_keyr  s          r   r  z"CodeParser._resolve_module_to_file  s     i//0
j*Qvh7	///**955**69hGt&&'4+A+AA##))+-5	*r   c                   t        |      j                  }|dk(  r1	 ||z  j                         }|j                         rt	        |      S 	 y|dk(  rt|j                  dd      }|dz   |dz   g}|}	 |D ]2  }	||	z  }|j                         st	        |j                               c S  ||j                  k(  r	 y|j                  }U|dv r|j                  d      r||z  }
g d	}|
j                         rt	        |
j                               S |D ]>  }|
j                  |      }|j                         s%t	        |j                               c S  |
j                         r[|D ]5  }|
d
| z  }|j                         st	        |j                               c S  y| j                  j                  ||      }|r|S y|dk(  r|j                  d      ri||z  }
|
j                         rt	        |
j                               S |
j                  d      }|j                         rt	        |j                               S y|j                  d      rm	 |t        d      d }|j                  d      \  }}}|sy| j                  ||      }|1|dz  |z  }|j                         rt	        |j                               S yy# t
        t        f$ r Y yw xY w# t
        t        f$ r Y yw xY w)z)Language-aware module-to-file resolution.rO   Nr2   r  /r1   z/__init__.pyr4   r7   r9   rG   )r6   r8   r3   r5   rF   indexrI   rH   zpackage:lib)r   r  resolveis_filer   r   r   r$  r  with_suffixis_dirr   resolve_aliasr  	partition_find_dart_pubspec_root)r   re   r   r   r  r/   rel_path
candidatescurrent	candidaterQ  
extensionsextr  uri_bodypkg_name_sub_pathpubspec_roots                      r   r  zCodeParser._do_resolve_module  s    )_++
v$v-668>>#v;& $ x~~c3/H"U*H~,EFJ G!+ 5I$y0F~~'"6>>#3445 gnn,v u "..  CC  %!F*C
<<>t||~..% 5C!--c2F~~'"6>>#3445
 ;;=) 9!%%u!5!>>+#&v~~'7#889R G  22@@S#OB ?   %!F*<<>t||~..))'2>>#v~~/00, + "":. %c*o&67H,4,>,>s,C)Ha###'#?#?"H$L $/!-!5!@!>>+#&v~~'7#88 U Z( J  ,   s*   -J9 %K 2AK 9K
KK K c                   t        |      |f}| j                  j                  |      }||| j                  v r|S |}t        d      D ]  }|dz  }|j	                         rb	 |j                  dd      }t        j                  d|t        j                        }	|	r'|	j                  d	      |k(  r|| j                  |<   |c S |j                  |k(  r n|j                  } d| j                  |<   y# t        $ r d}Y w xY w)
a&  Walk up from ``start`` to find a ``pubspec.yaml`` whose ``name:``
        matches ``pkg_name``. Returns the directory containing that pubspec,
        or None if no match is found. Result is cached per (start, pkg_name)
        pair so repeated lookups within one parse pass are cheap.
        N   zpubspec.yamlr#  r$  )encodingr&  r!   z^name:\s*([\w-]+)r	   )r   r   r   ranger  	read_textr   r  r   	MULTILINErz  r  )
r   r  r  r  cachedr  r  pubspecr/  ms
             r   r  z"CodeParser._find_dart_pubspec_root)  s	    Z*	))--i8d.F.F!FMr 	%A.G ",,gi,PD II2D",,Gx/:AD,,Y7"N~~(nnG	% /3  +  Ds   !C11C?>C?c                r    ||v r| j                  ||d      S ||v r| j                  |||   ||      }|r|S |S )z>Resolve a bare call name to a qualified target, with fallback.N)r  ro  )r   r  r   r   r   r   r  s          r   r  zCodeParser._resolve_call_targetH  sU     %==It<<
"44:i0)XH r   c                    | j                  |||      }|sy| j                  ||      }|r|S | j                  ||d      S )zHResolve an imported symbol to its defining qualified name when possible.N)r  _resolve_exported_symbolr  )r   symbol_namere   r   r   r  export_targets          r   ro  z#CodeParser._resolve_imported_symbol[  sL     //	8L55hL  }}[(D99r   c           	        | d| }|| j                   v r| j                   |   S ||f}|
t               }||v ry|j                  |       t        |      }| j	                  |      }|dvry	 |j                         }| j                  |      }	|	sy|	j                  |      }
| j                  |
j                  ||      \  }}||v r$| j                  ||d      }|| j                   |<   |S |
j                  j                  D ]  }|j                  dk7  rd}d}d}|j                  D ]b  }|j                  dk(  r|}|j                  dk(  r-|j                  j!                  dd	
      j#                  d      }Q|j                  dk(  sad}d ||j                  D ]  }|j                  dk7  r|j                  D cg c]-  }|j                  dv r|j                  j!                  dd	
      / }}|sX|d   }|d   }||k7  rh|rR| j%                  |||      }|r=| j'                  |||      xs | j                  ||d      }|| j                   |<   |c c S | j                  ||d      }|| j                   |<   |c c S  |s|s| j%                  |||      }|s| j'                  |||      }|s|| j                   |<   |c S  d| j                   |<   y# t        t        f$ r Y yw xY wc c}w )z@Resolve a JS/TS symbol through common re-export/barrel patterns.r  Nr  r  Fexport_clauser  r#  r$  r%  r4  *Texport_specifierr  r  r   )r   r  r  r   r   r   r   r   r   r  r  r  r  r-  r.  r/  r0  r^  r  r  )r   module_filer  seenr  keyr   r   r   r  r  r   r   resultr6  r  target_modulehas_star_exportr9  r  r  r  exported_nameoriginal_nameresolved_modules                            r   r  z#CodeParser._resolve_exported_symboll  sW    #m2k]3	111,,Y77K(<5D$;K ''-EE	__&F !!(+||F# %)$<$<NNHf%
!
M -']];TBF39D%%i0M^^,, 9	&Ezz// M M#O~~ +88.$'MXX)$'HHOOGIO$N$T$TUZ$[MXX_&*O+ ()22 "Dyy$66  %)MM 99(MM 		(((CE 
 ! $)"IM$)!HM$3 $*.*F*F);+ +%)%B%B /& &U!%}ot!T # DJD55i@#)M!]]=+tLF;AD--i8!M5": ="&">">!;# #!::'dF ?E11)<%s9	&v 04!!),] ) 		Ns   -K :2K-K*)K*c                (    |r
| d| d| S | d| S )zFCreate a qualified name: file_path::ClassName.name or file_path::name.r  r  r   )r   r   r   r  s       r   r  zCodeParser._qualify  s.    [?"31TF;;Btf%%r   c                   |dk(  rO|j                   dk(  r@|j                  D ]0  }|j                   dk(  s|j                  j                  dd      c S  y|dk(  r]|j                   d	k(  ry
|j                   dk(  r>|j                  D ]/  }|j                   dv s|j                  j                  dd      c S  |dv rz|j                   dk(  rk|j                  D ]\  }|j                   dv st	        |j                        D ]2  }|j                   dk(  s|j                  j                  dd      c c S   y |dk(  r}|j                  D ]n  }|j                   dk(  r|j                  j                  dd      c S |j                   dk(  sA|j                  dk7  sQ|j                  j                  dd      c S  |dv r>|dk(  r9|j                  D ]*  }|j                   dv s| j                  |||      }|s(|c S  |dk(  rN|j                   dk(  r?|j                  D ]0  }|j                   dk(  s|j                  j                  dd      c S  |dk(  rN|j                   dk(  r?|j                  D ]0  }|j                   dk(  s|j                  j                  dd      c S  |dk(  rN|j                   dk(  r?|j                  D ]0  }|j                   dk(  s|j                  j                  dd      c S  |dk(  rq|j                   d k(  rb|j                  D ]S  }|j                   d!k(  s|j                  D ]2  }|j                   d"k(  s|j                  j                  dd      c c S  U |j                  D ]/  }|j                   d#v s|j                  j                  dd      c S  |dk(  rD|j                   d$k(  r5|j                  D ]&  }|j                   d%k(  s| j                  |||      c S  y)&z7Extract the name from a class/function definition node.rI   r   r  r#  r$  r%  NrE   r   constructorr   )receivefallbackr  r{   r.  rK   barewordpackages   package)r@   r?   rN   r6  )function_declaratorpointer_declaratorrN   r|   rO   rz   r  r:   r~   field_identifierrB   rY   	user_typetype_identifier)r  r   r  rA  simple_identifierr  r[   	type_spec)r.  r-  r/  r0  r  rK  )r   rC  r   r   r6  r9  r  s          r   rK  zCodeParser._get_name  s    v$))/C"C H::- ::,,WY,GGH z!yy44$yy99!]] LEzz%<<$zz000KKL &4998N+N  ::!TT'7 N88|3#&88??79?#MMN    v H::+ ::,,WY,GG::*uzzZ/G ::,,WY,GG	H ++
0B &::!NN!^^E8TBF%	& v$))/B"B H::- ::,,WY,GGH v$))/D"D H::' ::,,WY,GGH t		-A A H::!33 ::,,WY,GGH
 w4990C#C N::,$~~ N88'88#&88??79?#MMNN ]] 	DEzz   zz(((CC	D t		-? ? A::,>>%4@@A r   c                   |j                   D ]  }|j                  dk7  r|j                   D ]  }|j                  dk7  r|j                   D ]  }|j                  dk(  r#|j                  j                  dd      c c c S |j                  dk(  sE|j                   D ]6  }|j                  dk(  s|j                  j                  dd      c c c c S     y y)	a  Extract the receiver type from a Go method_declaration.

        For ``func (s *T) Foo() {...}`` returns ``"T"``. For ``func (T) Foo()``
        also returns ``"T"``. Returns None if no receiver is present.

        The receiver is always the first ``parameter_list`` child of a
        Go ``method_declaration`` and contains a single ``parameter_declaration``
        whose type is either a ``type_identifier`` or a ``pointer_type``
        wrapping one. See: #190
        parameter_listparameter_declarationr  r#  r$  r%  pointer_typeNr  )r   rC  r6  paramr9  	ptr_childs         r   rY  z CodeParser._get_go_receiver_type6  s     ]] 	Ezz-- "::!88 >> "Cxx#44"xxwyIIxx>1), "I(~~1BB'0~~'<'<$+I (= (" !" !""	"" !	" r   c                L   |j                   D ]1  }d}|j                  |v s|j                  j                  dd      c S  |dk(  rZ|j                   D cg c].  }|j                  dk(  r|j                  j                  dd      0 }}|rddj	                  |       d	S y
c c}w )z#Extract parameter list as a string.)
parametersformal_parametersr  formal_parameter_listr#  r$  r%  rE   	parameter(z, )N)r-  r.  r/  r0  ra  )r   rC  r   r   r6  param_typesr@   r$   s           r   r(  zCodeParser._get_paramsT  s    ]] 	DEK zz[(zz(((CC	D z! 66[( gi8F 
 499V,-Q//s   3B!c                x   |j                   D ]/  }|j                  dv s|j                  j                  dd      c S  |dk(  rwt	        |j                         D ]_  \  }}|j                  dk(  s|dz   t        |j                         k  s2|j                   |dz      j                  j                  dd      c S  y)	z*Extract return type annotation if present.)r.  r%   r  return_type_definitionr#  r$  r%  r2   z->r	   N)r-  r.  r/  r0  r[  r  )r   rC  r   r   r6  is         r   r<  zCodeParser._get_return_typeh  s    ]] 	DEzzaazz(((CC	D x%dmm4 W5::%!a%#dmm2D*D==Q/44;;GI;VVW r   c           
     4   g }|dk(  ro|j                   D ]^  }|j                  dk(  s|j                   D ]=  }|j                  dv s|j                  |j                  j	                  dd             ? ` |S |dv rP|j                   D ]?  }|j                  dv s|j                  j	                  dd      }|j                  |       A |S |d	k(  r|j                   D ]  }|j                  d
k(  s|j                   D ]  }|j                  dk(  r-|j                  |j                  j	                  dd             ?|j                  dk(  sO|j                   D ]?  }	|	j                  dk(  s|j                  |	j                  j	                  dd                 |S |dk(  rp|j                   D ]_  }|j                  dk(  s|j                   D ]>  }|j                  dk(  s|j                  |j                  j	                  dd             @ a |S |dv rn|j                   D ]]  }|j                  dv s|j                   D ]=  }|j                  dv s|j                  |j                  j	                  dd             ? _ |S |dk(  r|j                   D ]  }|j                  dk(  s|j                   D ]_  }|j                  dk(  s|j                   D ]>  }	|	j                  dk(  s|j                  |	j                  j	                  dd             @ a  |S |dk(  r|j                   D ]  }|j                  dk(  s|j                   D ]  }|j                  dv s|j                   D ]_  }
|
j                  dk(  s|
j                   D ]>  }|j                  dk(  s|j                  |j                  j	                  dd             @ a   |S |dk(  r,|j                   D ]  }|j                  dk(  r|j                   D ]  }|j                  dk(  r-|j                  |j                  j	                  dd             ?|j                  dk(  sO|j                   D ]>  }|j                  dk(  s|j                  |j                  j	                  dd             @  |j                  dk(  s|j                   D ]>  }|j                  dk(  s|j                  |j                  j	                  dd             @  |S |dk(  r|j                   D ]  }|j                  dk(  s|j                   D ]`  }|j                  dk(  s|j                   D ]?  }	|	j                  dk(  s|j                  |	j                  j	                  dd              ` b  |S ) z.Extract base classes / implemented interfaces.r2   argument_list)r  r!  r#  r$  r%  )r<   r=   rA   )
superclasssuper_interfacesextends_typeimplements_typer  	supertypedelegation_specifierrD   extends_clauser  generic_typer?   base_class_clause)r7   r4   r9   )r0  implements_clause)r  r  nested_identifierrE   inheritance_specifieruser_defined_typer  r:   r  )struct_typeinterface_typefield_declaration_listrI   r*  mixins
interfacesrB   r  )r-  r.  r	  r/  r0  )r   rC  r   r   rP  r6  r  r/  r9  r  
field_nodefr  s                r   rL  zCodeParser._get_basest  s{   x U::0$~~ U88'BB!LL)STUUx o 55 ':: " 
 !::,,WY,GDLL&'j [   *::!11$~~ 	*88'88!LL)ST XX7), *#(::1B#B$)LL(-

(9(9')(9(T%& %**		**X A  U::!44$~~ U88'88!LL)STUU| s << U::!HH$~~ U88']]!LL)STUUn e # _::!88$~~ _88'::), _#(::#=$)LL1B1B7S\1B1]$^___` S  c::,$~~ c88'HH.1ll c
#-??6N#N-7-@-@ %c+,665F+F,1LLwW`9a,b%ccccN =   U::-$~~ [88'88!LL)ST XX1%(\\ [#$66->#>$)LLwy1Y$Z[	[ ZZ</$~~ U88'88!LL)STUU4     	*::!88$~~ *88{2), *#(::1B#B$)LL(-

(9(9')(9(T%& %***	* r   c                   g }|j                   j                  dd      j                         }|dk(  r|j                  dk(  rQ|j                  D ]@  }|j                  dk(  s|j                  |j                   j                  dd              |S  |S |j                  D ]>  }|j                  dk(  s|j                  |j                   j                  dd             @ |S |dv r`|j                  D ]O  }|j                  dk(  s|j                   j                  dd      j                  d	      }|j                  |       Q |S |d
k(  r|j                  D ]   }|j                  dk(  r|j                  D ]p  }|j                  dk(  s|j                  D ]O  }	|	j                  dk(  s|	j                   j                  dd      }|j                  |j                  d             Q r |j                  dk(  s|j                  D ]O  }	|	j                  dk(  s|	j                   j                  dd      }|j                  |j                  d             Q  |S |dk(  r@|j                  |j                  dd      j                  d      j                                |S |dv r_|j                  D ]N  }|j                  dv s|j                   j                  dd      j                  d      }|j                  |       P |S |dv rC|j                         }
t        |
      dk\  r#|j                  |
d   j                  d             |S |dk(  rc|j                  D ]R  }|j                  dk(  s|j                   j                  dd      j                  d      }|sB|j                  |       T |S |dk(  r!g }
g }d}|j                  D ]  }|j                  dk(  r-|
j                  |j                   j                  dd             ?|j                  dk(  rN|j                  D ]>  }|j                  dk(  s|j                  |j                   j                  dd             @ |j                  dk(  sd} d j                  |
      }|r|D ]  }|j                  | d |         |S |r|j                  | d!       |S |r|j                  |       |S |d"k(  r| j                  |      }|d#v r| j                  |      D ]v  \  }}|j                  dk(  r-|j                  |j                   j                  dd             n3|j                  dk(  r$| j                  |      }|r|j                  |        |S  |S |d$k(  r>d%|v r8t        j                  d&|      }|r |j                  |j!                  d'             |S |d(k(  r#d*fd) |      }|r|j                  |       |S |j                  |       |S )+z.Extract import targets as module/path strings.r#  r$  r%  r2   r   r  r  r  r4  r:   import_spec_listimport_specinterpreted_string_literalr  r;   zuse r!   ;)r@   r?   )system_lib_stringstring_literalz<>")r<   r=   r  r  rE   rD   Fr  namespace_selectorsnamespace_wildcardTr  z.*rJ   libraryr  r   r>   r  z['"](.*?)['"]r	   rI   c                    | j                   dk(  r,| j                  j                  dd      j                  d      S | j                  D ]  } |      }||c S  y )NrD  r#  r$  r%  r4  )r.  r/  r0  r^  r-  )r  r@   r  _find_string_literals      r   rJ  z8CodeParser._extract_import.<locals>._find_string_literal:  s_    66--66===CII%PP &A1!4F)%& r   r  r"   )r/  r0  r^  r.  r-  r	  r$  rstripr  r  ra  _r_call_func_name_r_iter_args_r_first_string_argr  r   rz  )r   rC  r   r   r`  r/  r6  valr  r  parts	selectorsis_wildcardr9  rQ  r   	func_name_namevaluer  rJ  s                       @r   r_  zCodeParser._extract_import  s   yy	:@@Bxyy33!]] Ezz]2uzz'8'8'8'STP WV M "]] UEzz]2uzz'8'8'8'STUL G << (::)**++GI+FLLUSCNN3'(B {  ;::!33 % C995%)]] C#$66-I#I*+&&--	-*RC$+NN399S>$BCC ZZ=0"^^ ;66%AA"#&&--	-"JC#NN399S>:;;x _ NN4<<3::3?EEGHZ Y % (::!HH**++GI+FLLVTCNN3'(T M ++JJLE5zQuRy//45D C # ,::)**++GI+FLLSQCs+	,~ u  EIK '::-LL!2!279!2!MNZZ#88$~~ Y88|3%,,SXX__WY_-WXY ZZ#77"&K' 88E?D% 5DNNdV1TF#345V S $r{+P O t$L K _..t4I<<$($5$5d$; LE5zz\1uzz'8'8'8'STx/"66t<#NN3/4 CB 3 D 		"6=NN5;;q>2( '  't,Cs#
  NN4 r   c                   |j                   sy|j                   d   }|j                  dk(  r?|j                   D ]/  }|j                  dv s|j                  j                  dd      c S  y|dk(  re|j                  d	k(  rVd
}|j                   D ]D  }|j                  dv r|sd}|j                  dk(  s'|j                  j                  dd      c S  y|dk(  rc|j                  dk(  rT|j                   D ]D  }|j                  dk(  s|j                  j                  dd      j	                         }|xs dc S  y|dk(  r*|j                  dk(  r|j                   r|j                   d   }|dk(  rO|j                  dk(  r@|j                   D ]0  }|j                  dk(  s|j                  j                  dd      c S  y|j                  dv r|j                  j                  dd      S |j                  dk(  r|j                  j                  dd      S |dv rW|j                  dv rIt        |j                         D ]0  }|j                  dk(  s|j                  j                  dd      c S  yd}|j                  |v rt        |j                         D ]  }|j                  dv r|j                  j                  dd      c S |j                  dk(  s@|j                   D ]2  }	|	j                  dk(  s|	j                  j                  dd      c c S   |j                  j                  dd      S |j                  dv r|j                  j                  dd      S |j                  dk(  r|j                  j                  dd      S y) z.Extract the function/method name being called.Nr   r   )r  r  r#  r$  r%  rN   r   F)[]Tr  rO   r   r  rE   r  rK   r   r   )r  r  r6  r  r.  )r!  r  field_expressionselector_expressionnavigation_expression)r  rA  r  
field_namer  navigation_suffixr  )scoped_identifierqualified_namenamespace_operator)r-  r.  r/  r0  r^  r  )
r   rC  r   r   r  r6  receiver_skippedr
  member_typesr9  s
             r   rd  zCodeParser._get_call_nameK  s   }}a  99-- H::!BB ::,,WY,GGH  v$))/C"C$ 	H::+' (,$::- ::,,WY,GG	H  v$))y"8 '::/**++GI+FLLNC;$&	'
  z!ejjL&@U^^NN1%E v$))/G"G H::) ::,,WY,GGH  ::<<::$$WY$?? ::#::$$WY$?? &5:: :
 ,
 "%..1 H::- ::,,WY,GGH 

 ::% "%..1 	N:: "  !::,,WY,GG::!44$~~ N88'::#&88??79?#MMN	N ::$$WY$?? ::@@::$$WY$?? ::--::$$WY$??r   c                   |j                   D ]t  }|j                  dk(  r6|j                  j                  dd      }| j	                  |      rd|fc S  y|j                  dk(  sY| j                  |      }d}t        |j                         D ]/  }|j                  dv s|j                  j                  dd      } n |r| j	                  |      r||fc S t        |j                         D ]I  }|j                  dv s|j                  j                  dd      }| j	                  |      rd|fc c S   y |j                  j                  dd      }|j                  d      d	   }| j	                  |      rd|fc S  y y)
zExtract ``(base_name, component_name)`` for a JSX element.

        ``base_name`` is set for member-style elements such as
        ``<UI.MarkdownMsg />`` and ``None`` for plain component tags such as
        ``<MarkdownMsg />``.
        r  r#  r$  r%  Nr  r  r  r  )r-  r.  r/  r0  _looks_like_component_name _get_member_expression_root_namer  r  )	r   rC  r6  r   rq  rr  r9  r/  tails	            r   rn  z'CodeParser._get_jsx_component_reference  sw    ]] 	Ezz\)zz(((C2248 $<'zz00 AA%H	!%#ENN3 Cxx#HH),)S "d&E&En&U%~66#ENN3 $Cxx#HH"xxwyI::4@$($</#$ zz(((Czz#r*2248 $<'3	4 r   c                    |j                   D ]R  }|j                  dk(  r|j                  j                  dd      c S |j                  dk(  sA| j	                  |      c S  y)z>Return the leftmost identifier for a nested member expression.r  r#  r$  r%  r  N)r-  r.  r/  r0  rf  )r   rC  r6  s      r   rf  z+CodeParser._get_member_expression_root_name  s`    ]] 	DEzz\)zz(((CCzz00<<UCC		D
 r   c                B    t        |       xr | d   j                         S )z9Return True for JSX names that look like user components.r   )r'   r  )r   s    r   re  z%CodeParser._looks_like_component_name  s     Dz/d1goo//r   >   eachonlyro  todofailing
concurrentc                ,   |j                   sy|j                   d   }|j                  dk7  ryd}t        |j                         D ]/  }|j                  dv s|j                  j	                  dd      } n || j
                  vry|j                   D ]  }|j                  dk(  r|j                  j	                  dd      c S |j                  dk(  sA|j                   D ]2  }|j                  dk(  s|j                  j	                  dd      c c S   y)	zMReturn the base object name for member-expression calls like describe.only().Nr   r  r  r#  r$  r%  r  )r-  r.  r  r/  r0  _TEST_MODIFIER_SUFFIXES)r   rC  r   r  	rightmostr6  r  s          r   re  zCodeParser._get_base_call_name  s   }}a ::,,#'	enn- 	EzzBB!JJ--gi-H		 D888^^ 	LEzz\)zz(((CCzz00"^^ LEzz\1$zz000KKL		L r   c                    | j                   D ]/  }|j                  dv s|j                  j                  dd      c S  y)z.Extract the function name from an R call node.)r  ra  r#  r$  r%  Nr  )r  r6  s     r   rM  zCodeParser._r_call_func_name  sG     '' 	DEzzAAzz(((CC	D r   c                V   | j                   D ]  }|j                  dk(  s|j                   D ]x  }|j                  dk(  s|j                   D ]W  }|j                  dk(  s|j                   D ]6  }|j                  dk(  s|j                  j                  dd      c c c c S  Y z  y y)	z<Extract the first string argument value from an R call node.r  argumentr  r3  r#  r$  r%  Nr  )r  r6  r  r9  scs        r   rO  zCodeParser._r_first_string_arg  s     '' 		Ezz[( >> YCxx:-#&<< YC"xx83*-,, !YB')ww2B'B/1ww~~gi~/X(X(X!YYY 		 r   c              #    K   | j                   D ]  }|j                  dk7  r|j                   D ]  }|j                  dk7  rt        d |j                   D              }|r\d}d}|j                   D ]B  }|j                  dk(  r ||j                  j	                  dd      }2|j                  d	vsA|}D ||f |j                   D ]  }|j                  d
vsd|f     y yw)z>Yield (name_str, value_node) pairs from an R call's arguments.r  rt  c              3  :   K   | ]  }|j                   d k(    yw)r  N)r.  )r   r9  s     r   r   z*CodeParser._r_iter_args.<locals>.<genexpr>#  s     ESXX_Es   Nr  r#  r$  r%  )r  r  )r  )r-  r.  r   r/  r0  )r  r6  r  has_eqr   rV  r9  s          r   rN  zCodeParser._r_iter_args  s      '' 	Ezz[(~~ "88z)EEED E"|| (88|3#&88??79?#MD XXZ7$'E	(
  -'"|| "8861#'+-!""$ +	s   B-C(0(C(C(c                H    | j                  |      D ]  \  }}||k(  s|c S  y)z0Find a named argument's value node in an R call.N)rN  )ru  r  arg_namer   rV  s        r   _r_find_named_argzCodeParser._r_find_named_arg4  s4     ++I6 	KD%x	 r   c                   |j                   }t        |      dk  ry|d   |d   |d   }}}|j                  dvry|j                  dk(  r	|j                  dk(  r|j                  j	                  d	d
      }t        ||      }|rdnd}| j                  |||      }| j                  |||      }|j                  t        ||||j                  d   dz   |j                  d   dz   ||||	             |r| j                  ||d      n|}|j                  t        d||||j                  d   dz                | j                  |||||||||	|

       y|j                  dk(  r]|j                  dk(  rN| j                  |      }|dv r9|j                  j	                  d	d
      }| j                  |||||||||	|
|      S y)z>Handle R binary_operator nodes: name <- function(...) { ... }.r  Fr   r	   r  )z<-r  rz   r  r#  r$  r%  r   r  r  Nr  r  r  r  r   r   Tr   setRefClasssetClass
setGeneric)assign_name)r-  r  r.  r/  r0  r   r  r(  r	  r   r1  r  r.   r  rM  _handle_r_class_call)r   rC  r   r   r   r  r  r  r  r   r   r-  leftoprightr   r(   r   r  r$   r  	call_funcr  s                          r   r  z$CodeParser._handle_r_binary_operator@  s     ==x=1"1+x{HQK%b77+%::..4993L99##GI#>D'i8G$6*DdIGI%%eXv>FLL# ,,Q/!3+a/!+
 
 # oy$?(1  LL  #&&q)A-  ##vxE5 /%] $ 
 ::DII$=..u5IEE"ii..wy.I0068Yu#^ +	 1   r   c                6   | j                  |      }|sy|dv rJ| j                  |||      }|D ]1  }|j                  t        d||||j                  d   dz                3 y|dv r| j                  |||||||||	|

      S |r|| j                  |||      }|rg| j                  |||      }| j                  ||||	xs i |
xs
 t                     }|j                  t        d	||||j                  d   dz                | j                  |||||||||	|


       y)z6Handle R call nodes for imports and class definitions.FrG  ru  r   r	   r  Tr~  r   r}  )rM  r_  r	  r.   r1  r  rd  r  r  r  r  )r   rC  r   r   r   r  r  r  r  r   r   rT  r`  ra  r  r  r/   s                    r   r  zCodeParser._handle_r_call  sk    **40	88**46BG% 
X'$%'))!,q0  AA,,fh	5%M  ++D(FCI~y/R22y($"m&<su X !!'))!,q0  	&(Iue+N! 	  	

 r   c                   | j                  |      xs |}|sy| j                  |||      }|j                  t        d|||j                  d   dz   |j
                  d   dz   ||             |j                  t        d||||j                  d   dz                | j                  |d      }|| j                  ||||||||	|
	       y	)
z<Handle setClass/setRefClass/setGeneric calls -> Class nodes.Fr  r   r	   r  r  r  methodsT)	rO  r  r	  r   r1  r  r.   r{  _extract_r_methods)r   rC  r   r   r   r  r  r  r  r   r   r  
class_namer  methods_lists                  r   r  zCodeParser._handle_r_class_call  s     --d3B{
MM*iI	X''*Q.^^A&*'
 	 	X!!!$q(
 	 --dI>###fh	ujM r   c
                   | j                  |      D ]  \  }
}|
r||j                  dk7  r| j                  |
||      }| j                  |||      }|j	                  t        d|
||j                  d   dz   |j                  d   dz   |||             |j	                  t        d| j                  ||d      |||j                  d   dz                | j                  ||||||||
||		
        y)
z<Extract methods from a setRefClass methods = list(...) call.Nrz   r  r   r	   )r   r   r   r   r    r   r#   r$   r  r  r}  )
rN  r.  r  r(  r	  r   r1  r  r.   r  )r   	list_callr   r   r   r  r  r  r   r   r  func_defr  r$   s                 r   r  zCodeParser._extract_r_methods  s    &*%6%6y%A 	!K("2}} 55k9jII%%h&AFLL ##//2Q6!++A.2!&	 	 LL}}ZDA #))!,q0  ##&(Iue **%+ $ 3	r   )r  rv  )r   r   )r   r   r  r"   )r   r   r  %tuple[list[NodeInfo], list[EdgeInfo]])r   r   r   bytesr  r  )r   r   rN  zlist[CellInfo]r  r   r  r  )r  list[NodeInfo]r  list[EdgeInfo]r   r   r  r  )r   r  r  r"   )NNNNr   )r   r  r   r   r   r   r  r  r  r  r  r"   r  r"   r   Optional[dict[str, str]]r   Optional[set[str]]r  r   r  rv  rK  )r   r  r  z#tuple[Optional[str], Optional[str]])r   r  r   r   r   r   r  r  r  r  r  r"   r  r"   r   r  r   r  r  r   r  r'   )r   r   r  r  r  r'   )r   r  r   r   r  r  r  r"   r  r"   r  rv  )r  r   r   r  r   r   r   r   r  r  r  r  r  r"   r  r"   r   r  r   r  r  r'   )r  r   r   r  r   r   r   r   r  r  r  r  r  r"   r  r"   r   r  r   r  r  r   r  r'   )r   r  r   r   r   r   r  r  r  r  r  r"   r   r  r   r  r  r   r  r'   )
r   r   r   r  r   r   r  r  r  rv  )r   r   r   r   r  r  r  r"   r  r"   r   r  r   r  r  rv  )
r   r   r   r   r   rV   r   set[str]r  r"   )r  r   r   r  r   r   r   r   r  r  r  r"   r  r"   r   r  r   r  r  rv  )r   )r   r   r   r   r   r   r  r   r  r  r   rV   r   r  r0   r   r  rv  )r   r  r   r   r   r   r  r   r  r  r   rV   r   r  r  rv  )r  r   r   r  r   r   r  r  r  r  r  r"   r  r"   r  r'   )r   r   r   r  r  ztuple[dict[str, str], set[str]])r   r  r  rv  )r   r   r   r  r   rV   r  rv  )re   r   r   rV   r  rv  )re   r   r   r   r   r   r  r"   )r  r   r  r   r  zOptional[Path])r  r   r   r   r   r   r   rV   r   r  r  r   )
r  r   re   r   r   r   r   r   r  r"   r   )r   r   r  r   r  zOptional[set[tuple[str, str]]]r  r"   )r   r   r   r   r  r"   r  r   )r   r   r   r   r  r"   )r   r   r   r  r  r"   )r   r   r   r  r  z	list[str])r  z#Optional[tuple[Optional[str], str]])r   r   r  r'   )rz  r   )r   r  r   r   r   r   r  r  r  r  r  r"   r  r"   r   r  r   r  r  r'   )r   r  r   r   r   r   r  r  r  r  r  r"   r  r"   r   r  r   r  r  r"   r  r'   )r   r  r   r   r   r   r  r  r  r  r  r   r   r  r   r  r  rv  )Tr   r   r   r   r  r   r   r   r   r   r  r  r  rb  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r!  staticmethodr"  	frozensetr;  r  r  r  r  r  r  r  rl  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  ro  r  r  rK  rY  r(  r<  rL  r_  rd  rn  rf  re  rp  re  rM  rO  rN  classmethodr{  r  r  r  r  r   r   r   r   r   j  s   TM'>.Qfm$m$"'m$	.m$^@$@$"'@$	.@$DRDRD"'RD	.RDhA$A$ A$ 	A$
 
/A$F``"'`	.`D%% % 	%
 
%N N #, *.(,/3,0f f 	f
 f f f 'f &f -f *f f 
fP(
!&	,:e e 	e
 e e e 'e &e -e *e e 
eN" " 	"
 
"HL! L! 	L!
 L! 'L! &L! 
L!\' ' 	'
 ' ' ' ' '' &' -' *' 
'Z: : 	:
 : : : : ': &: -: *: : 
:xk k 	k
 k k k 'k &k -k *k k 
kZK K 	K
 K K K 'K &K -K *K K 
KZ  @ %=U U 	U
 U U U 'U &U -U *U U 
Un> > 	>
 > > > '> &> -> *> > 
>@N N 	N
 N N N 'N -N *N N 
N`j j 	j
 j j j 'j -j *j j 
jX  	
   
,k k 	k
 k k k 'k &k -k *k k 
kZ" " 	"
 " '" &" -" *" 
"H  	
 #   
B VH%K gv./L
 & ' 
C C 	C
 C C C 'C &C -C *C 
C\   	
   #    
@  	
    #   
<#
 #
 	#

 #
 #
 #
 ##
  #
 
#
J  	
    #   
*  	
    #   
*a a 	a
 a a a 'a &a 
aFG)!G)+0G)	(G)R&#+&	&&Q!&Q+0&Q>L&Q	&QP;#&;4B;	;4&)58	$WW&)W58W	Wr%(	>  	
 #   
&:: : 	:
 : 
:* 04	gg g -	g
 
gR&Yv<(
`DsjeN!F 0 0
 ( ) 6      2  A!A-0A=@AA&4A 'A 9FA -	A
 *A 
AF4!4-04=@44&44 '4 9F4 -	4
 *4 
4x &*'!'-0'=@''&4' '' 9F' -	'
 *' #' 
'R'!&'25'BE''&4' ' -	'
 *' 
'r   r   )r   r   r  r'   )r   )r   r   r   r   r   ztuple[str, ...]r  r'   )r   r   r  r   )+r   
__future__r   r   rW  loggingr  dataclassesr   r   pathlibr   typingr   r   tree_sitter_language_packr   tsconfig_resolverr
   r   compile
IGNORECASErx  	getLoggerr   r   r   r.   rW   r   ry   r   r   r   r   r   r  r   r   r   r   r   r   r   r   r   <module>r     sn	   #    	 (  ' ( /z  

2MM 
		8	$ . . . . . ..)	8.)	<.) L.) 
<	.)
 E.) 
4.) 
6.) V.) 
8.) 
6.) E.) 
5.) E.) 	#.) 	#.)  E!.)" 
8#.)$ g%.)& E'.)( g).)* J+.), E-.). V/.)0 	#1.)2 L3.)4 l5.)6 
67.)8 
69.): 	&;.)< 
3=.)> E?.)@ VA.)B 	&C.)D 
6E.)F [.) ~ .d+&!"+&&0+& &0+& 
)	+&
 	
+& 5+& N+& 
/	0+& 
12+&  +& Wh+& +&  F!+&" "$89#+&$ P%+&& 
!89'+&(  )+&.
 J  #$$%!#89U+&" +Z0)$%0)Q0) Q0) 
J	0)
 	!#7
80) _0) !#<=0) 
	 0) 
!"0) #%>?0) X)*0) 
	 0) /1OP0) %&0) $%0)  
!#78!0)" #%;<#0), """##$ !"78"# 	"'(#Y0)% 0d&'!#:;&'%&&' %&&' 
	&'
 	
 &' &' !"&' 
	&' 
&'  !&' VH&' &&' _23&' &' "#&'  
'(!&'" "##&'$ $$     "34K&'# &P$%vh$%$&67$% $&67$% 
/0	$%
 	
$%  23$%  ">?$% 
	$% 
$% &(DE$% V]#$% &$%  $%"  !#$%$  %$%& 
&(@A'$%( K)$%* ## "#45K 23'( G$%! $P BJJyBJJxBJJyBJJ{BJJ{BJJy BJJBJJBJJ$%BJJ$%BJJBJJzBJJ !BJJ#$BJJ!"BJJ~BJJ           <
 >@
+:	9_: _:r   